diff options
Diffstat (limited to 'include/vulkan/vulkan.hpp')
| -rw-r--r-- | include/vulkan/vulkan.hpp | 7284 |
1 files changed, 7062 insertions, 222 deletions
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index 08be754..3da8746 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -82,7 +82,8 @@ # include <compare> #endif -static_assert( VK_HEADER_VERSION == 137 , "Wrong VK_HEADER_VERSION!" ); + +static_assert( VK_HEADER_VERSION == 139 , "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION @@ -170,6 +171,12 @@ static_assert( VK_HEADER_VERSION == 137 , "Wrong VK_HEADER_VERSION!" ); # endif #endif +#if __cplusplus >= 201402L +# define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]] +#else +# define VULKAN_HPP_DEPRECATED( msg ) +#endif + #if !defined(VULKAN_HPP_NAMESPACE) #define VULKAN_HPP_NAMESPACE vk #endif @@ -180,19 +187,31 @@ static_assert( VK_HEADER_VERSION == 137 , "Wrong VK_HEADER_VERSION!" ); namespace VULKAN_HPP_NAMESPACE { + #if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) template <typename T> class ArrayProxy { public: + VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT + : m_count(0) + , m_ptr(nullptr) + {} + VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t) VULKAN_HPP_NOEXCEPT : m_count(0) , m_ptr(nullptr) {} - ArrayProxy(typename std::remove_reference<T>::type & ptr) VULKAN_HPP_NOEXCEPT + ArrayProxy(T & value) VULKAN_HPP_NOEXCEPT + : m_count(1) + , m_ptr(&value) + {} + + template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0> + ArrayProxy(typename std::remove_const<T>::type & value) VULKAN_HPP_NOEXCEPT : m_count(1) - , m_ptr(&ptr) + , m_ptr(&value) {} ArrayProxy(uint32_t count, T * ptr) VULKAN_HPP_NOEXCEPT @@ -200,33 +219,44 @@ namespace VULKAN_HPP_NAMESPACE , m_ptr(ptr) {} - template <size_t N> - ArrayProxy(std::array<typename std::remove_const<T>::type, N> & data) VULKAN_HPP_NOEXCEPT - : m_count(N) - , m_ptr(data.data()) + template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0> + ArrayProxy(uint32_t count, typename std::remove_const<T>::type * ptr) VULKAN_HPP_NOEXCEPT + : m_count(count) + , m_ptr(ptr) + {} + + ArrayProxy(std::initializer_list<T> const& list) VULKAN_HPP_NOEXCEPT + : m_count(static_cast<uint32_t>(list.size())) + , m_ptr(list.begin()) {} - template <size_t N> - ArrayProxy(std::array<typename std::remove_const<T>::type, N> const& data) VULKAN_HPP_NOEXCEPT - : m_count(N) - , m_ptr(data.data()) + template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0> + ArrayProxy(std::initializer_list<typename std::remove_const<T>::type> const& list) VULKAN_HPP_NOEXCEPT + : m_count(static_cast<uint32_t>(list.size())) + , m_ptr(list.begin()) {} - template <class Allocator = std::allocator<typename std::remove_const<T>::type>> - ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data) VULKAN_HPP_NOEXCEPT - : m_count(static_cast<uint32_t>(data.size())) - , m_ptr(data.data()) + ArrayProxy(std::initializer_list<T> & list) VULKAN_HPP_NOEXCEPT + : m_count(static_cast<uint32_t>(list.size())) + , m_ptr(list.begin()) {} - template <class Allocator = std::allocator<typename std::remove_const<T>::type>> - ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data) VULKAN_HPP_NOEXCEPT - : m_count(static_cast<uint32_t>(data.size())) - , m_ptr(data.data()) + template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0> + ArrayProxy(std::initializer_list<typename std::remove_const<T>::type> & list) VULKAN_HPP_NOEXCEPT + : m_count(static_cast<uint32_t>(list.size())) + , m_ptr(list.begin()) {} - ArrayProxy(std::initializer_list<typename std::remove_reference<T>::type> const& data) VULKAN_HPP_NOEXCEPT - : m_count(static_cast<uint32_t>(data.end() - data.begin())) - , m_ptr(data.begin()) + template <typename Container> + ArrayProxy(Container const& container) VULKAN_HPP_NOEXCEPT + : m_count(static_cast<uint32_t>(container.size())) + , m_ptr(container.data()) + {} + + template <typename Container> + ArrayProxy(Container & container) VULKAN_HPP_NOEXCEPT + : m_count(static_cast<uint32_t>(container.size())) + , m_ptr(container.data()) {} const T * begin() const VULKAN_HPP_NOEXCEPT @@ -448,25 +478,25 @@ namespace VULKAN_HPP_NAMESPACE } // assignment operators - Flags<BitType> & operator=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT { m_mask = rhs.m_mask; return *this; } - Flags<BitType> & operator|=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT { m_mask |= rhs.m_mask; return *this; } - Flags<BitType> & operator&=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT { m_mask &= rhs.m_mask; return *this; } - Flags<BitType> & operator^=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=(Flags<BitType> const& rhs) VULKAN_HPP_NOEXCEPT { m_mask ^= rhs.m_mask; return *this; @@ -3213,6 +3243,10 @@ namespace VULKAN_HPP_NAMESPACE using DeviceSize = uint64_t; using SampleMask = uint32_t; + template <typename EnumType, EnumType value> + struct CppType + {}; + #ifdef VK_ENABLE_BETA_EXTENSIONS enum class AccelerationStructureBuildTypeKHR { @@ -6126,6 +6160,10 @@ namespace VULKAN_HPP_NAMESPACE } } + template<ObjectType value> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type + {}; + enum class PeerMemoryFeatureFlagBits : VkPeerMemoryFeatureFlags { eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, @@ -7936,6 +7974,8 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceTexelBufferAlignmentPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT, eCommandBufferInheritanceRenderPassTransformInfoQCOM = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM, eRenderPassTransformBeginInfoQCOM = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM, + ePhysicalDeviceRobustness2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, + ePhysicalDeviceRobustness2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, ePipelineLibraryCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR, ePhysicalDevicePipelineCreationCacheControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT, ePhysicalDeviceDiagnosticsConfigFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV, @@ -8485,6 +8525,8 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT : return "PhysicalDeviceTexelBufferAlignmentPropertiesEXT"; case StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM : return "CommandBufferInheritanceRenderPassTransformInfoQCOM"; case StructureType::eRenderPassTransformBeginInfoQCOM : return "RenderPassTransformBeginInfoQCOM"; + case StructureType::ePhysicalDeviceRobustness2FeaturesEXT : return "PhysicalDeviceRobustness2FeaturesEXT"; + case StructureType::ePhysicalDeviceRobustness2PropertiesEXT : return "PhysicalDeviceRobustness2PropertiesEXT"; case StructureType::ePipelineLibraryCreateInfoKHR : return "PipelineLibraryCreateInfoKHR"; case StructureType::ePhysicalDevicePipelineCreationCacheControlFeaturesEXT : return "PhysicalDevicePipelineCreationCacheControlFeaturesEXT"; case StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV : return "PhysicalDeviceDiagnosticsConfigFeaturesNV"; @@ -8542,7 +8584,9 @@ namespace VULKAN_HPP_NAMESPACE enum class SubpassDescriptionFlagBits : VkSubpassDescriptionFlags { ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX, - ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX + ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX, + eFragmentRegionQCOM = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM, + eShaderResolveQCOM = VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM }; VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlagBits value ) @@ -8551,6 +8595,8 @@ namespace VULKAN_HPP_NAMESPACE { case SubpassDescriptionFlagBits::ePerViewAttributesNVX : return "PerViewAttributesNVX"; case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX : return "PerViewPositionXOnlyNVX"; + case SubpassDescriptionFlagBits::eFragmentRegionQCOM : return "FragmentRegionQCOM"; + case SubpassDescriptionFlagBits::eShaderResolveQCOM : return "ShaderResolveQCOM"; default: return "invalid"; } } @@ -8842,11 +8888,47 @@ namespace VULKAN_HPP_NAMESPACE } } - template<ObjectType value> - struct cpp_type + template<typename T> + struct IndexTypeValue + {}; + + template <> + struct IndexTypeValue<uint16_t> + { + static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint16; + }; + + template <> + struct CppType<IndexType, IndexType::eUint16> + { + using Type = uint16_t; + }; + + template <> + struct IndexTypeValue<uint32_t> + { + static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint32; + }; + + template <> + struct CppType<IndexType, IndexType::eUint32> { + using Type = uint32_t; }; + template <> + struct IndexTypeValue<uint8_t> + { + static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint8EXT; + }; + + template <> + struct CppType<IndexType, IndexType::eUint8EXT> + { + using Type = uint8_t; + }; + + using AccessFlags = Flags<AccessFlagBits>; template <> struct FlagTraits<AccessFlagBits> @@ -8879,6 +8961,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( AccessFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -8913,10 +8996,12 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using AcquireProfilingLockFlagsKHR = Flags<AcquireProfilingLockFlagBitsKHR>; VULKAN_HPP_INLINE std::string to_string( AcquireProfilingLockFlagsKHR ) { + return "{}"; } @@ -8933,10 +9018,12 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagsKHR ) { + return "{}"; } #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits>; template <> struct FlagTraits<AttachmentDescriptionFlagBits> @@ -8969,6 +9056,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -8976,6 +9064,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using BufferCreateFlags = Flags<BufferCreateFlagBits>; template <> struct FlagTraits<BufferCreateFlagBits> @@ -9008,6 +9097,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( BufferCreateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -9019,6 +9109,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using BufferUsageFlags = Flags<BufferUsageFlagBits>; template <> struct FlagTraits<BufferUsageFlagBits> @@ -9051,6 +9142,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( BufferUsageFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -9071,13 +9163,16 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlags ) { + return "{}"; } + using BuildAccelerationStructureFlagsKHR = Flags<BuildAccelerationStructureFlagBitsKHR>; template <> struct FlagTraits<BuildAccelerationStructureFlagBitsKHR> @@ -9112,6 +9207,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( BuildAccelerationStructureFlagsKHR value ) { + if ( !value ) return "{}"; std::string result; @@ -9123,6 +9219,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using ColorComponentFlags = Flags<ColorComponentFlagBits>; template <> struct FlagTraits<ColorComponentFlagBits> @@ -9155,6 +9252,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ColorComponentFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -9165,6 +9263,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits>; template <> struct FlagTraits<CommandBufferResetFlagBits> @@ -9197,6 +9296,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( CommandBufferResetFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -9204,6 +9304,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits>; template <> struct FlagTraits<CommandBufferUsageFlagBits> @@ -9236,6 +9337,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( CommandBufferUsageFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -9245,6 +9347,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits>; template <> struct FlagTraits<CommandPoolCreateFlagBits> @@ -9277,6 +9380,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( CommandPoolCreateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -9286,6 +9390,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits>; template <> struct FlagTraits<CommandPoolResetFlagBits> @@ -9318,6 +9423,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( CommandPoolResetFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -9339,9 +9445,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( CommandPoolTrimFlags ) { + return "{}"; } + using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR>; template <> struct FlagTraits<CompositeAlphaFlagBitsKHR> @@ -9374,6 +9482,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( CompositeAlphaFlagsKHR value ) { + if ( !value ) return "{}"; std::string result; @@ -9384,6 +9493,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using ConditionalRenderingFlagsEXT = Flags<ConditionalRenderingFlagBitsEXT>; template <> struct FlagTraits<ConditionalRenderingFlagBitsEXT> @@ -9416,6 +9526,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ConditionalRenderingFlagsEXT value ) { + if ( !value ) return "{}"; std::string result; @@ -9423,6 +9534,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using CullModeFlags = Flags<CullModeFlagBits>; template <> struct FlagTraits<CullModeFlagBits> @@ -9455,6 +9567,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( CullModeFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -9463,6 +9576,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT>; template <> struct FlagTraits<DebugReportFlagBitsEXT> @@ -9495,6 +9609,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DebugReportFlagsEXT value ) { + if ( !value ) return "{}"; std::string result; @@ -9506,6 +9621,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using DebugUtilsMessageSeverityFlagsEXT = Flags<DebugUtilsMessageSeverityFlagBitsEXT>; template <> struct FlagTraits<DebugUtilsMessageSeverityFlagBitsEXT> @@ -9538,6 +9654,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageSeverityFlagsEXT value ) { + if ( !value ) return "{}"; std::string result; @@ -9548,6 +9665,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using DebugUtilsMessageTypeFlagsEXT = Flags<DebugUtilsMessageTypeFlagBitsEXT>; template <> struct FlagTraits<DebugUtilsMessageTypeFlagBitsEXT> @@ -9580,6 +9698,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageTypeFlagsEXT value ) { + if ( !value ) return "{}"; std::string result; @@ -9601,6 +9720,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagsEXT ) { + return "{}"; } @@ -9616,9 +9736,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagsEXT ) { + return "{}"; } + using DependencyFlags = Flags<DependencyFlagBits>; template <> struct FlagTraits<DependencyFlagBits> @@ -9651,6 +9773,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DependencyFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -9660,6 +9783,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using DescriptorBindingFlags = Flags<DescriptorBindingFlagBits>; template <> struct FlagTraits<DescriptorBindingFlagBits> @@ -9694,6 +9818,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DescriptorBindingFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -9704,6 +9829,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits>; template <> struct FlagTraits<DescriptorPoolCreateFlagBits> @@ -9736,6 +9862,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DescriptorPoolCreateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -9756,9 +9883,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlags ) { + return "{}"; } + using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits>; template <> struct FlagTraits<DescriptorSetLayoutCreateFlagBits> @@ -9791,6 +9920,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DescriptorSetLayoutCreateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -9813,16 +9943,20 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateCreateFlags ) { + return "{}"; } + using DeviceCreateFlags = Flags<DeviceCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlags ) { + return "{}"; } + using DeviceDiagnosticsConfigFlagsNV = Flags<DeviceDiagnosticsConfigFlagBitsNV>; template <> struct FlagTraits<DeviceDiagnosticsConfigFlagBitsNV> @@ -9855,6 +9989,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DeviceDiagnosticsConfigFlagsNV value ) { + if ( !value ) return "{}"; std::string result; @@ -9864,6 +9999,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using DeviceGroupPresentModeFlagsKHR = Flags<DeviceGroupPresentModeFlagBitsKHR>; template <> struct FlagTraits<DeviceGroupPresentModeFlagBitsKHR> @@ -9896,6 +10032,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DeviceGroupPresentModeFlagsKHR value ) { + if ( !value ) return "{}"; std::string result; @@ -9906,6 +10043,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits>; template <> struct FlagTraits<DeviceQueueCreateFlagBits> @@ -9938,6 +10076,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -9957,9 +10096,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagsKHR ) { + return "{}"; } + using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR>; template <> struct FlagTraits<DisplayPlaneAlphaFlagBitsKHR> @@ -9992,6 +10133,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DisplayPlaneAlphaFlagsKHR value ) { + if ( !value ) return "{}"; std::string result; @@ -10014,6 +10156,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagsKHR ) { + return "{}"; } @@ -10029,9 +10172,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( EventCreateFlags ) { + return "{}"; } + using ExternalFenceFeatureFlags = Flags<ExternalFenceFeatureFlagBits>; template <> struct FlagTraits<ExternalFenceFeatureFlagBits> @@ -10066,6 +10211,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ExternalFenceFeatureFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -10074,6 +10220,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using ExternalFenceHandleTypeFlags = Flags<ExternalFenceHandleTypeFlagBits>; template <> struct FlagTraits<ExternalFenceHandleTypeFlagBits> @@ -10108,6 +10255,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ExternalFenceHandleTypeFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -10118,6 +10266,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using ExternalMemoryFeatureFlags = Flags<ExternalMemoryFeatureFlagBits>; template <> struct FlagTraits<ExternalMemoryFeatureFlagBits> @@ -10152,6 +10301,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -10161,6 +10311,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV>; template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsNV> @@ -10193,6 +10344,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlagsNV value ) { + if ( !value ) return "{}"; std::string result; @@ -10202,6 +10354,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using ExternalMemoryHandleTypeFlags = Flags<ExternalMemoryHandleTypeFlagBits>; template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBits> @@ -10236,6 +10389,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -10253,6 +10407,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using ExternalMemoryHandleTypeFlagsNV = Flags<ExternalMemoryHandleTypeFlagBitsNV>; template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsNV> @@ -10285,6 +10440,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlagsNV value ) { + if ( !value ) return "{}"; std::string result; @@ -10295,6 +10451,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using ExternalSemaphoreFeatureFlags = Flags<ExternalSemaphoreFeatureFlagBits>; template <> struct FlagTraits<ExternalSemaphoreFeatureFlagBits> @@ -10329,6 +10486,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreFeatureFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -10337,6 +10495,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using ExternalSemaphoreHandleTypeFlags = Flags<ExternalSemaphoreHandleTypeFlagBits>; template <> struct FlagTraits<ExternalSemaphoreHandleTypeFlagBits> @@ -10371,6 +10530,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreHandleTypeFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -10382,6 +10542,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using FenceCreateFlags = Flags<FenceCreateFlagBits>; template <> struct FlagTraits<FenceCreateFlagBits> @@ -10414,6 +10575,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( FenceCreateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -10421,6 +10583,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using FenceImportFlags = Flags<FenceImportFlagBits>; template <> struct FlagTraits<FenceImportFlagBits> @@ -10455,6 +10618,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( FenceImportFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -10462,6 +10626,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using FormatFeatureFlags = Flags<FormatFeatureFlagBits>; template <> struct FlagTraits<FormatFeatureFlagBits> @@ -10494,6 +10659,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -10526,6 +10692,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits>; template <> struct FlagTraits<FramebufferCreateFlagBits> @@ -10558,6 +10725,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -10565,6 +10733,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using GeometryFlagsKHR = Flags<GeometryFlagBitsKHR>; template <> struct FlagTraits<GeometryFlagBitsKHR> @@ -10599,6 +10768,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( GeometryFlagsKHR value ) { + if ( !value ) return "{}"; std::string result; @@ -10607,6 +10777,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using GeometryInstanceFlagsKHR = Flags<GeometryInstanceFlagBitsKHR>; template <> struct FlagTraits<GeometryInstanceFlagBitsKHR> @@ -10641,6 +10812,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( GeometryInstanceFlagsKHR value ) { + if ( !value ) return "{}"; std::string result; @@ -10663,6 +10835,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( HeadlessSurfaceCreateFlagsEXT ) { + return "{}"; } @@ -10679,10 +10852,12 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( IOSSurfaceCreateFlagsMVK ) { + return "{}"; } #endif /*VK_USE_PLATFORM_IOS_MVK*/ + using ImageAspectFlags = Flags<ImageAspectFlagBits>; template <> struct FlagTraits<ImageAspectFlagBits> @@ -10715,6 +10890,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ImageAspectFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -10732,6 +10908,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using ImageCreateFlags = Flags<ImageCreateFlagBits>; template <> struct FlagTraits<ImageCreateFlagBits> @@ -10764,6 +10941,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ImageCreateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -10798,10 +10976,12 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ImagePipeSurfaceCreateFlagsFUCHSIA ) { + return "{}"; } #endif /*VK_USE_PLATFORM_FUCHSIA*/ + using ImageUsageFlags = Flags<ImageUsageFlagBits>; template <> struct FlagTraits<ImageUsageFlagBits> @@ -10834,6 +11014,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ImageUsageFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -10850,6 +11031,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using ImageViewCreateFlags = Flags<ImageViewCreateFlagBits>; template <> struct FlagTraits<ImageViewCreateFlagBits> @@ -10882,6 +11064,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ImageViewCreateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -10889,6 +11072,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using IndirectCommandsLayoutUsageFlagsNV = Flags<IndirectCommandsLayoutUsageFlagBitsNV>; template <> struct FlagTraits<IndirectCommandsLayoutUsageFlagBitsNV> @@ -10921,6 +11105,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( IndirectCommandsLayoutUsageFlagsNV value ) { + if ( !value ) return "{}"; std::string result; @@ -10930,6 +11115,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using IndirectStateFlagsNV = Flags<IndirectStateFlagBitsNV>; template <> struct FlagTraits<IndirectStateFlagBitsNV> @@ -10962,6 +11148,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( IndirectStateFlagsNV value ) { + if ( !value ) return "{}"; std::string result; @@ -10969,10 +11156,12 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using InstanceCreateFlags = Flags<InstanceCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlags ) { + return "{}"; } @@ -10989,10 +11178,12 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( MacOSSurfaceCreateFlagsMVK ) { + return "{}"; } #endif /*VK_USE_PLATFORM_MACOS_MVK*/ + using MemoryAllocateFlags = Flags<MemoryAllocateFlagBits>; template <> struct FlagTraits<MemoryAllocateFlagBits> @@ -11027,6 +11218,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( MemoryAllocateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11036,6 +11228,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using MemoryHeapFlags = Flags<MemoryHeapFlagBits>; template <> struct FlagTraits<MemoryHeapFlagBits> @@ -11068,6 +11261,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( MemoryHeapFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11088,9 +11282,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags ) { + return "{}"; } + using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits>; template <> struct FlagTraits<MemoryPropertyFlagBits> @@ -11123,6 +11319,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( MemoryPropertyFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11150,10 +11347,12 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( MetalSurfaceCreateFlagsEXT ) { + return "{}"; } #endif /*VK_USE_PLATFORM_METAL_EXT*/ + using PeerMemoryFeatureFlags = Flags<PeerMemoryFeatureFlagBits>; template <> struct FlagTraits<PeerMemoryFeatureFlagBits> @@ -11188,6 +11387,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PeerMemoryFeatureFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11198,6 +11398,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using PerformanceCounterDescriptionFlagsKHR = Flags<PerformanceCounterDescriptionFlagBitsKHR>; template <> struct FlagTraits<PerformanceCounterDescriptionFlagBitsKHR> @@ -11230,6 +11431,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PerformanceCounterDescriptionFlagsKHR value ) { + if ( !value ) return "{}"; std::string result; @@ -11238,6 +11440,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits>; template <> struct FlagTraits<PipelineCacheCreateFlagBits> @@ -11270,6 +11473,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11277,17 +11481,21 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlags ) { + return "{}"; } + using PipelineCompilerControlFlagsAMD = Flags<PipelineCompilerControlFlagBitsAMD>; VULKAN_HPP_INLINE std::string to_string( PipelineCompilerControlFlagsAMD ) { + return "{}"; } @@ -11303,6 +11511,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PipelineCoverageModulationStateCreateFlagsNV ) { + return "{}"; } @@ -11318,6 +11527,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PipelineCoverageReductionStateCreateFlagsNV ) { + return "{}"; } @@ -11333,9 +11543,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PipelineCoverageToColorStateCreateFlagsNV ) { + return "{}"; } + using PipelineCreateFlags = Flags<PipelineCreateFlagBits>; template <> struct FlagTraits<PipelineCreateFlagBits> @@ -11368,6 +11580,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PipelineCreateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11392,6 +11605,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using PipelineCreationFeedbackFlagsEXT = Flags<PipelineCreationFeedbackFlagBitsEXT>; template <> struct FlagTraits<PipelineCreationFeedbackFlagBitsEXT> @@ -11424,6 +11638,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PipelineCreationFeedbackFlagsEXT value ) { + if ( !value ) return "{}"; std::string result; @@ -11433,10 +11648,12 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlags ) { + return "{}"; } @@ -11452,34 +11669,43 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagsEXT ) { + return "{}"; } + using PipelineDynamicStateCreateFlags = Flags<PipelineDynamicStateCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlags ) { + return "{}"; } + using PipelineInputAssemblyStateCreateFlags = Flags<PipelineInputAssemblyStateCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlags ) { + return "{}"; } + using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlags ) { + return "{}"; } + using PipelineMultisampleStateCreateFlags = Flags<PipelineMultisampleStateCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlags ) { + return "{}"; } @@ -11495,6 +11721,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationConservativeStateCreateFlagsEXT ) { + return "{}"; } @@ -11510,13 +11737,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationDepthClipStateCreateFlagsEXT ) { + return "{}"; } + using PipelineRasterizationStateCreateFlags = Flags<PipelineRasterizationStateCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlags ) { + return "{}"; } @@ -11532,9 +11762,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateStreamCreateFlagsEXT ) { + return "{}"; } + using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits>; template <> struct FlagTraits<PipelineShaderStageCreateFlagBits> @@ -11567,6 +11799,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11575,6 +11808,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using PipelineStageFlags = Flags<PipelineStageFlagBits>; template <> struct FlagTraits<PipelineStageFlagBits> @@ -11607,6 +11841,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11639,24 +11874,30 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using PipelineTessellationStateCreateFlags = Flags<PipelineTessellationStateCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlags ) { + return "{}"; } + using PipelineVertexInputStateCreateFlags = Flags<PipelineVertexInputStateCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlags ) { + return "{}"; } + using PipelineViewportStateCreateFlags = Flags<PipelineViewportStateCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlags ) { + return "{}"; } @@ -11672,9 +11913,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( PipelineViewportSwizzleStateCreateFlagsNV ) { + return "{}"; } + using QueryControlFlags = Flags<QueryControlFlagBits>; template <> struct FlagTraits<QueryControlFlagBits> @@ -11707,6 +11950,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( QueryControlFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11714,6 +11958,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits>; template <> struct FlagTraits<QueryPipelineStatisticFlagBits> @@ -11746,6 +11991,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( QueryPipelineStatisticFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11763,13 +12009,16 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using QueryPoolCreateFlags = Flags<QueryPoolCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlags ) { + return "{}"; } + using QueryResultFlags = Flags<QueryResultFlagBits>; template <> struct FlagTraits<QueryResultFlagBits> @@ -11802,6 +12051,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( QueryResultFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11812,6 +12062,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using QueueFlags = Flags<QueueFlagBits>; template <> struct FlagTraits<QueueFlagBits> @@ -11844,6 +12095,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( QueueFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11855,6 +12107,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using RenderPassCreateFlags = Flags<RenderPassCreateFlagBits>; template <> struct FlagTraits<RenderPassCreateFlagBits> @@ -11887,6 +12140,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( RenderPassCreateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11894,6 +12148,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using ResolveModeFlags = Flags<ResolveModeFlagBits>; template <> struct FlagTraits<ResolveModeFlagBits> @@ -11928,6 +12183,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ResolveModeFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11938,6 +12194,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using SampleCountFlags = Flags<SampleCountFlagBits>; template <> struct FlagTraits<SampleCountFlagBits> @@ -11970,6 +12227,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( SampleCountFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -11983,6 +12241,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using SamplerCreateFlags = Flags<SamplerCreateFlagBits>; template <> struct FlagTraits<SamplerCreateFlagBits> @@ -12015,6 +12274,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( SamplerCreateFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -12023,13 +12283,16 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using SemaphoreCreateFlags = Flags<SemaphoreCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlags ) { + return "{}"; } + using SemaphoreImportFlags = Flags<SemaphoreImportFlagBits>; template <> struct FlagTraits<SemaphoreImportFlagBits> @@ -12064,6 +12327,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( SemaphoreImportFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -12071,6 +12335,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using SemaphoreWaitFlags = Flags<SemaphoreWaitFlagBits>; template <> struct FlagTraits<SemaphoreWaitFlagBits> @@ -12105,6 +12370,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( SemaphoreWaitFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -12112,20 +12378,25 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using ShaderCorePropertiesFlagsAMD = Flags<ShaderCorePropertiesFlagBitsAMD>; VULKAN_HPP_INLINE std::string to_string( ShaderCorePropertiesFlagsAMD ) { + return "{}"; } + using ShaderModuleCreateFlags = Flags<ShaderModuleCreateFlagBits>; VULKAN_HPP_INLINE std::string to_string( ShaderModuleCreateFlags ) { + return "{}"; } + using ShaderStageFlags = Flags<ShaderStageFlagBits>; template <> struct FlagTraits<ShaderStageFlagBits> @@ -12158,6 +12429,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ShaderStageFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -12178,6 +12450,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits>; template <> struct FlagTraits<SparseImageFormatFlagBits> @@ -12210,6 +12483,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( SparseImageFormatFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -12219,6 +12493,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits>; template <> struct FlagTraits<SparseMemoryBindFlagBits> @@ -12251,6 +12526,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( SparseMemoryBindFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -12258,6 +12534,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using StencilFaceFlags = Flags<StencilFaceFlagBits>; template <> struct FlagTraits<StencilFaceFlagBits> @@ -12290,6 +12567,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( StencilFaceFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -12311,10 +12589,12 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( StreamDescriptorSurfaceCreateFlagsGGP ) { + return "{}"; } #endif /*VK_USE_PLATFORM_GGP*/ + using SubgroupFeatureFlags = Flags<SubgroupFeatureFlagBits>; template <> struct FlagTraits<SubgroupFeatureFlagBits> @@ -12347,6 +12627,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( SubgroupFeatureFlags value ) { + if ( !value ) return "{}"; std::string result; @@ -12362,13 +12643,14 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits>; template <> struct FlagTraits<SubpassDescriptionFlagBits> { enum : VkFlags { - allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) | VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) + allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) | VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) | VkFlags(SubpassDescriptionFlagBits::eFragmentRegionQCOM) | VkFlags(SubpassDescriptionFlagBits::eShaderResolveQCOM) }; }; @@ -12394,14 +12676,18 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlags value ) { + if ( !value ) return "{}"; std::string result; if ( value & SubpassDescriptionFlagBits::ePerViewAttributesNVX ) result += "PerViewAttributesNVX | "; if ( value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX ) result += "PerViewPositionXOnlyNVX | "; + if ( value & SubpassDescriptionFlagBits::eFragmentRegionQCOM ) result += "FragmentRegionQCOM | "; + if ( value & SubpassDescriptionFlagBits::eShaderResolveQCOM ) result += "ShaderResolveQCOM | "; return "{ " + result.substr(0, result.size() - 3) + " }"; } + using SurfaceCounterFlagsEXT = Flags<SurfaceCounterFlagBitsEXT>; template <> struct FlagTraits<SurfaceCounterFlagBitsEXT> @@ -12434,6 +12720,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( SurfaceCounterFlagsEXT value ) { + if ( !value ) return "{}"; std::string result; @@ -12441,6 +12728,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR>; template <> struct FlagTraits<SurfaceTransformFlagBitsKHR> @@ -12473,6 +12761,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( SurfaceTransformFlagsKHR value ) { + if ( !value ) return "{}"; std::string result; @@ -12488,6 +12777,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR>; template <> struct FlagTraits<SwapchainCreateFlagBitsKHR> @@ -12520,6 +12810,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( SwapchainCreateFlagsKHR value ) { + if ( !value ) return "{}"; std::string result; @@ -12529,6 +12820,7 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + using ToolPurposeFlagsEXT = Flags<ToolPurposeFlagBitsEXT>; template <> struct FlagTraits<ToolPurposeFlagBitsEXT> @@ -12561,6 +12853,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ToolPurposeFlagsEXT value ) { + if ( !value ) return "{}"; std::string result; @@ -12586,6 +12879,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ValidationCacheCreateFlagsEXT ) { + return "{}"; } @@ -12602,6 +12896,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( ViSurfaceCreateFlagsNN ) { + return "{}"; } #endif /*VK_USE_PLATFORM_VI_NN*/ @@ -12619,6 +12914,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( WaylandSurfaceCreateFlagsKHR ) { + return "{}"; } #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ @@ -12636,6 +12932,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( Win32SurfaceCreateFlagsKHR ) { + return "{}"; } #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -12653,6 +12950,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( XcbSurfaceCreateFlagsKHR ) { + return "{}"; } #endif /*VK_USE_PLATFORM_XCB_KHR*/ @@ -12670,6 +12968,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE std::string to_string( XlibSurfaceCreateFlagsKHR ) { + return "{}"; } #endif /*VK_USE_PLATFORM_XLIB_KHR*/ @@ -12993,6 +13292,7 @@ namespace VULKAN_HPP_NAMESPACE : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {} }; + [[noreturn]] static void throwResultException( Result result, char const * message ) { switch ( result ) @@ -13724,6 +14024,8 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct PhysicalDeviceRayTracingPropertiesNV; struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV; + struct PhysicalDeviceRobustness2FeaturesEXT; + struct PhysicalDeviceRobustness2PropertiesEXT; struct PhysicalDeviceSampleLocationsPropertiesEXT; struct PhysicalDeviceSamplerFilterMinmaxProperties; using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties; @@ -14075,11 +14377,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eSurfaceKHR> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eSurfaceKHR> { using type = SurfaceKHR; }; + template <> + struct CppType<ObjectType, ObjectType::eSurfaceKHR> + { + using Type = SurfaceKHR; + }; + class DebugReportCallbackEXT { public: @@ -14154,11 +14462,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eDebugReportCallbackEXT> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDebugReportCallbackEXT> { using type = DebugReportCallbackEXT; }; + template <> + struct CppType<ObjectType, ObjectType::eDebugReportCallbackEXT> + { + using Type = DebugReportCallbackEXT; + }; + class DebugUtilsMessengerEXT { public: @@ -14233,11 +14547,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eDebugUtilsMessengerEXT> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDebugUtilsMessengerEXT> { using type = DebugUtilsMessengerEXT; }; + template <> + struct CppType<ObjectType, ObjectType::eDebugUtilsMessengerEXT> + { + using Type = DebugUtilsMessengerEXT; + }; + class DisplayKHR { public: @@ -14312,11 +14632,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eDisplayKHR> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDisplayKHR> { using type = DisplayKHR; }; + template <> + struct CppType<ObjectType, ObjectType::eDisplayKHR> + { + using Type = DisplayKHR; + }; + class SwapchainKHR { public: @@ -14391,11 +14717,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eSwapchainKHR> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eSwapchainKHR> { using type = SwapchainKHR; }; + template <> + struct CppType<ObjectType, ObjectType::eSwapchainKHR> + { + using Type = SwapchainKHR; + }; + class Semaphore { public: @@ -14470,11 +14802,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eSemaphore> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eSemaphore> { using type = Semaphore; }; + template <> + struct CppType<ObjectType, ObjectType::eSemaphore> + { + using Type = Semaphore; + }; + class Fence { public: @@ -14549,11 +14887,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eFence> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eFence> { using type = Fence; }; + template <> + struct CppType<ObjectType, ObjectType::eFence> + { + using Type = Fence; + }; + class PerformanceConfigurationINTEL { public: @@ -14628,11 +14972,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PerformanceConfigurationINTEL ) == sizeof( VkPerformanceConfigurationINTEL ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::ePerformanceConfigurationINTEL> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::ePerformanceConfigurationINTEL> { using type = PerformanceConfigurationINTEL; }; + template <> + struct CppType<ObjectType, ObjectType::ePerformanceConfigurationINTEL> + { + using Type = PerformanceConfigurationINTEL; + }; + class QueryPool { public: @@ -14707,11 +15057,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eQueryPool> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eQueryPool> { using type = QueryPool; }; + template <> + struct CppType<ObjectType, ObjectType::eQueryPool> + { + using Type = QueryPool; + }; + class Buffer { public: @@ -14786,11 +15142,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eBuffer> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eBuffer> { using type = Buffer; }; + template <> + struct CppType<ObjectType, ObjectType::eBuffer> + { + using Type = Buffer; + }; + class PipelineLayout { public: @@ -14865,11 +15227,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::ePipelineLayout> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::ePipelineLayout> { using type = PipelineLayout; }; + template <> + struct CppType<ObjectType, ObjectType::ePipelineLayout> + { + using Type = PipelineLayout; + }; + class DescriptorSet { public: @@ -14944,11 +15312,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eDescriptorSet> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDescriptorSet> { using type = DescriptorSet; }; + template <> + struct CppType<ObjectType, ObjectType::eDescriptorSet> + { + using Type = DescriptorSet; + }; + class Pipeline { public: @@ -15023,11 +15397,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::ePipeline> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::ePipeline> { using type = Pipeline; }; + template <> + struct CppType<ObjectType, ObjectType::ePipeline> + { + using Type = Pipeline; + }; + class ImageView { public: @@ -15102,11 +15482,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eImageView> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eImageView> { using type = ImageView; }; + template <> + struct CppType<ObjectType, ObjectType::eImageView> + { + using Type = ImageView; + }; + class Image { public: @@ -15181,11 +15567,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eImage> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eImage> { using type = Image; }; + template <> + struct CppType<ObjectType, ObjectType::eImage> + { + using Type = Image; + }; + class AccelerationStructureKHR { public: @@ -15260,10 +15652,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( AccelerationStructureKHR ) == sizeof( VkAccelerationStructureKHR ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eAccelerationStructureKHR> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eAccelerationStructureKHR> { using type = AccelerationStructureKHR; }; + + template <> + struct CppType<ObjectType, ObjectType::eAccelerationStructureKHR> + { + using Type = AccelerationStructureKHR; + }; using AccelerationStructureNV = AccelerationStructureKHR; class DescriptorUpdateTemplate @@ -15340,10 +15738,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eDescriptorUpdateTemplate> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDescriptorUpdateTemplate> { using type = DescriptorUpdateTemplate; }; + + template <> + struct CppType<ObjectType, ObjectType::eDescriptorUpdateTemplate> + { + using Type = DescriptorUpdateTemplate; + }; using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; class Event @@ -15420,11 +15824,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eEvent> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eEvent> { using type = Event; }; + template <> + struct CppType<ObjectType, ObjectType::eEvent> + { + using Type = Event; + }; + class CommandBuffer { public: @@ -16077,11 +16487,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eCommandBuffer> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eCommandBuffer> { using type = CommandBuffer; }; + template <> + struct CppType<ObjectType, ObjectType::eCommandBuffer> + { + using Type = CommandBuffer; + }; + class DeviceMemory { public: @@ -16156,11 +16572,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eDeviceMemory> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDeviceMemory> { using type = DeviceMemory; }; + template <> + struct CppType<ObjectType, ObjectType::eDeviceMemory> + { + using Type = DeviceMemory; + }; + class BufferView { public: @@ -16235,11 +16657,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eBufferView> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eBufferView> { using type = BufferView; }; + template <> + struct CppType<ObjectType, ObjectType::eBufferView> + { + using Type = BufferView; + }; + class CommandPool { public: @@ -16314,11 +16742,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eCommandPool> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eCommandPool> { using type = CommandPool; }; + template <> + struct CppType<ObjectType, ObjectType::eCommandPool> + { + using Type = CommandPool; + }; + class PipelineCache { public: @@ -16393,11 +16827,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::ePipelineCache> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::ePipelineCache> { using type = PipelineCache; }; + template <> + struct CppType<ObjectType, ObjectType::ePipelineCache> + { + using Type = PipelineCache; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS class DeferredOperationKHR { @@ -16473,10 +16913,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DeferredOperationKHR ) == sizeof( VkDeferredOperationKHR ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eDeferredOperationKHR> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDeferredOperationKHR> { using type = DeferredOperationKHR; }; + + template <> + struct CppType<ObjectType, ObjectType::eDeferredOperationKHR> + { + using Type = DeferredOperationKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ class DescriptorPool @@ -16553,11 +16999,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eDescriptorPool> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDescriptorPool> { using type = DescriptorPool; }; + template <> + struct CppType<ObjectType, ObjectType::eDescriptorPool> + { + using Type = DescriptorPool; + }; + class DescriptorSetLayout { public: @@ -16632,11 +17084,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eDescriptorSetLayout> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDescriptorSetLayout> { using type = DescriptorSetLayout; }; + template <> + struct CppType<ObjectType, ObjectType::eDescriptorSetLayout> + { + using Type = DescriptorSetLayout; + }; + class Framebuffer { public: @@ -16711,11 +17169,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eFramebuffer> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eFramebuffer> { using type = Framebuffer; }; + template <> + struct CppType<ObjectType, ObjectType::eFramebuffer> + { + using Type = Framebuffer; + }; + class IndirectCommandsLayoutNV { public: @@ -16790,11 +17254,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( IndirectCommandsLayoutNV ) == sizeof( VkIndirectCommandsLayoutNV ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eIndirectCommandsLayoutNV> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eIndirectCommandsLayoutNV> { using type = IndirectCommandsLayoutNV; }; + template <> + struct CppType<ObjectType, ObjectType::eIndirectCommandsLayoutNV> + { + using Type = IndirectCommandsLayoutNV; + }; + class RenderPass { public: @@ -16869,11 +17339,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eRenderPass> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eRenderPass> { using type = RenderPass; }; + template <> + struct CppType<ObjectType, ObjectType::eRenderPass> + { + using Type = RenderPass; + }; + class Sampler { public: @@ -16948,11 +17424,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eSampler> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eSampler> { using type = Sampler; }; + template <> + struct CppType<ObjectType, ObjectType::eSampler> + { + using Type = Sampler; + }; + class SamplerYcbcrConversion { public: @@ -17027,10 +17509,16 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eSamplerYcbcrConversion> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eSamplerYcbcrConversion> { using type = SamplerYcbcrConversion; }; + + template <> + struct CppType<ObjectType, ObjectType::eSamplerYcbcrConversion> + { + using Type = SamplerYcbcrConversion; + }; using SamplerYcbcrConversionKHR = SamplerYcbcrConversion; class ShaderModule @@ -17107,11 +17595,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eShaderModule> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eShaderModule> { using type = ShaderModule; }; + template <> + struct CppType<ObjectType, ObjectType::eShaderModule> + { + using Type = ShaderModule; + }; + class ValidationCacheEXT { public: @@ -17186,11 +17680,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eValidationCacheEXT> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eValidationCacheEXT> { using type = ValidationCacheEXT; }; + template <> + struct CppType<ObjectType, ObjectType::eValidationCacheEXT> + { + using Type = ValidationCacheEXT; + }; + class Queue { public: @@ -17328,11 +17828,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eQueue> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eQueue> { using type = Queue; }; + template <> + struct CppType<ObjectType, ObjectType::eQueue> + { + using Type = Queue; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE class Device; template <typename Dispatch> class UniqueHandleTraits<AccelerationStructureKHR, Dispatch> { public: using deleter = ObjectDestroy<Device, Dispatch>; }; @@ -19370,11 +19876,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eDevice> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDevice> { using type = Device; }; + template <> + struct CppType<ObjectType, ObjectType::eDevice> + { + using Type = Device; + }; + class DisplayModeKHR { public: @@ -19449,11 +19961,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eDisplayModeKHR> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eDisplayModeKHR> { using type = DisplayModeKHR; }; + template <> + struct CppType<ObjectType, ObjectType::eDisplayModeKHR> + { + using Type = DisplayModeKHR; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE template <typename Dispatch> class UniqueHandleTraits<Device, Dispatch> { public: using deleter = ObjectDestroy<NoParent, Dispatch>; }; using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>; @@ -20076,11 +20594,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::ePhysicalDevice> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::ePhysicalDevice> { using type = PhysicalDevice; }; + template <> + struct CppType<ObjectType, ObjectType::ePhysicalDevice> + { + using Type = PhysicalDevice; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE class Instance; template <typename Dispatch> class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch> { public: using deleter = ObjectDestroy<Instance, Dispatch>; }; @@ -20449,11 +20973,17 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" ); template <> - struct cpp_type<ObjectType::eInstance> + struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type<ObjectType::eInstance> { using type = Instance; }; + template <> + struct CppType<ObjectType, ObjectType::eInstance> + { + using Type = Instance; + }; + #ifndef VULKAN_HPP_NO_SMART_HANDLE template <typename Dispatch> class UniqueHandleTraits<Instance, Dispatch> { public: using deleter = ObjectDestroy<NoParent, Dispatch>; }; using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>; @@ -20497,6 +21027,7 @@ namespace VULKAN_HPP_NAMESPACE struct AabbPositionsKHR { + VULKAN_HPP_CONSTEXPR AabbPositionsKHR( float minX_ = {}, float minY_ = {}, float minZ_ = {}, @@ -20558,6 +21089,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAabbPositionsKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAabbPositionsKHR*>( this ); @@ -20568,6 +21100,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAabbPositionsKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AabbPositionsKHR const& ) const = default; #else @@ -20587,6 +21120,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: float minX = {}; float minY = {}; @@ -20594,6 +21129,7 @@ namespace VULKAN_HPP_NAMESPACE float maxX = {}; float maxY = {}; float maxZ = {}; + }; static_assert( sizeof( AabbPositionsKHR ) == sizeof( VkAabbPositionsKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AabbPositionsKHR>::value, "struct wrapper is not a standard layout!" ); @@ -20607,14 +21143,12 @@ namespace VULKAN_HPP_NAMESPACE } DeviceOrHostAddressConstKHR( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ = {} ) - { - deviceAddress = deviceAddress_; - } + : deviceAddress( deviceAddress_ ) + {} DeviceOrHostAddressConstKHR( const void* hostAddress_ ) - { - hostAddress = hostAddress_; - } + : hostAddress( hostAddress_ ) + {} DeviceOrHostAddressConstKHR & setDeviceAddress( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ ) VULKAN_HPP_NOEXCEPT { @@ -20657,6 +21191,8 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureGeometryTrianglesDataKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryTrianglesDataKHR; + AccelerationStructureGeometryTrianglesDataKHR( VULKAN_HPP_NAMESPACE::Format vertexFormat_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR vertexData_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize vertexStride_ = {}, @@ -20700,7 +21236,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - AccelerationStructureGeometryTrianglesDataKHR & setVertexData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR vertexData_ ) VULKAN_HPP_NOEXCEPT + AccelerationStructureGeometryTrianglesDataKHR & setVertexData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const & vertexData_ ) VULKAN_HPP_NOEXCEPT { vertexData = vertexData_; return *this; @@ -20718,18 +21254,19 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - AccelerationStructureGeometryTrianglesDataKHR & setIndexData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR indexData_ ) VULKAN_HPP_NOEXCEPT + AccelerationStructureGeometryTrianglesDataKHR & setIndexData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const & indexData_ ) VULKAN_HPP_NOEXCEPT { indexData = indexData_; return *this; } - AccelerationStructureGeometryTrianglesDataKHR & setTransformData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR transformData_ ) VULKAN_HPP_NOEXCEPT + AccelerationStructureGeometryTrianglesDataKHR & setTransformData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const & transformData_ ) VULKAN_HPP_NOEXCEPT { transformData = transformData_; return *this; } + operator VkAccelerationStructureGeometryTrianglesDataKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureGeometryTrianglesDataKHR*>( this ); @@ -20740,6 +21277,9 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR*>( this ); } + + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryTrianglesDataKHR; const void* pNext = {}; @@ -20749,14 +21289,23 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::IndexType indexType = VULKAN_HPP_NAMESPACE::IndexType::eUint16; VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR indexData = {}; VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR transformData = {}; + }; static_assert( sizeof( AccelerationStructureGeometryTrianglesDataKHR ) == sizeof( VkAccelerationStructureGeometryTrianglesDataKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureGeometryTrianglesDataKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eAccelerationStructureGeometryTrianglesDataKHR> + { + using Type = AccelerationStructureGeometryTrianglesDataKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureGeometryAabbsDataKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryAabbsDataKHR; + AccelerationStructureGeometryAabbsDataKHR( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR data_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize stride_ = {} ) VULKAN_HPP_NOEXCEPT : data( data_ ) @@ -20786,7 +21335,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - AccelerationStructureGeometryAabbsDataKHR & setData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR data_ ) VULKAN_HPP_NOEXCEPT + AccelerationStructureGeometryAabbsDataKHR & setData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const & data_ ) VULKAN_HPP_NOEXCEPT { data = data_; return *this; @@ -20798,6 +21347,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAccelerationStructureGeometryAabbsDataKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureGeometryAabbsDataKHR*>( this ); @@ -20808,19 +21358,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR*>( this ); } + + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryAabbsDataKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR data = {}; VULKAN_HPP_NAMESPACE::DeviceSize stride = {}; + }; static_assert( sizeof( AccelerationStructureGeometryAabbsDataKHR ) == sizeof( VkAccelerationStructureGeometryAabbsDataKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureGeometryAabbsDataKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eAccelerationStructureGeometryAabbsDataKHR> + { + using Type = AccelerationStructureGeometryAabbsDataKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureGeometryInstancesDataKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryInstancesDataKHR; + AccelerationStructureGeometryInstancesDataKHR( VULKAN_HPP_NAMESPACE::Bool32 arrayOfPointers_ = {}, VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR data_ = {} ) VULKAN_HPP_NOEXCEPT : arrayOfPointers( arrayOfPointers_ ) @@ -20856,12 +21418,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - AccelerationStructureGeometryInstancesDataKHR & setData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR data_ ) VULKAN_HPP_NOEXCEPT + AccelerationStructureGeometryInstancesDataKHR & setData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const & data_ ) VULKAN_HPP_NOEXCEPT { data = data_; return *this; } + operator VkAccelerationStructureGeometryInstancesDataKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureGeometryInstancesDataKHR*>( this ); @@ -20872,14 +21435,24 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR*>( this ); } + + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryInstancesDataKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 arrayOfPointers = {}; VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR data = {}; + }; static_assert( sizeof( AccelerationStructureGeometryInstancesDataKHR ) == sizeof( VkAccelerationStructureGeometryInstancesDataKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureGeometryInstancesDataKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eAccelerationStructureGeometryInstancesDataKHR> + { + using Type = AccelerationStructureGeometryInstancesDataKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS @@ -20891,35 +21464,32 @@ namespace VULKAN_HPP_NAMESPACE } AccelerationStructureGeometryDataKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR triangles_ = {} ) - { - triangles = triangles_; - } + : triangles( triangles_ ) + {} AccelerationStructureGeometryDataKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryAabbsDataKHR aabbs_ ) - { - aabbs = aabbs_; - } + : aabbs( aabbs_ ) + {} AccelerationStructureGeometryDataKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR instances_ ) - { - instances = instances_; - } + : instances( instances_ ) + {} - AccelerationStructureGeometryDataKHR & setTriangles( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR triangles_ ) VULKAN_HPP_NOEXCEPT + AccelerationStructureGeometryDataKHR & setTriangles( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR const & triangles_ ) VULKAN_HPP_NOEXCEPT { - triangles = triangles_; + memcpy( &triangles, &triangles_, sizeof(VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR)); return *this; } - AccelerationStructureGeometryDataKHR & setAabbs( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryAabbsDataKHR aabbs_ ) VULKAN_HPP_NOEXCEPT + AccelerationStructureGeometryDataKHR & setAabbs( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryAabbsDataKHR const & aabbs_ ) VULKAN_HPP_NOEXCEPT { - aabbs = aabbs_; + memcpy( &aabbs, &aabbs_, sizeof(VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryAabbsDataKHR)); return *this; } - AccelerationStructureGeometryDataKHR & setInstances( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR instances_ ) VULKAN_HPP_NOEXCEPT + AccelerationStructureGeometryDataKHR & setInstances( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR const & instances_ ) VULKAN_HPP_NOEXCEPT { - instances = instances_; + memcpy( &instances, &instances_, sizeof(VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR)); return *this; } @@ -20954,6 +21524,8 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureGeometryKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryKHR; + AccelerationStructureGeometryKHR( VULKAN_HPP_NAMESPACE::GeometryTypeKHR geometryType_ = VULKAN_HPP_NAMESPACE::GeometryTypeKHR::eTriangles, VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR geometry_ = {}, VULKAN_HPP_NAMESPACE::GeometryFlagsKHR flags_ = {} ) VULKAN_HPP_NOEXCEPT @@ -20991,7 +21563,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - AccelerationStructureGeometryKHR & setGeometry( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR geometry_ ) VULKAN_HPP_NOEXCEPT + AccelerationStructureGeometryKHR & setGeometry( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR const & geometry_ ) VULKAN_HPP_NOEXCEPT { geometry = geometry_; return *this; @@ -21003,6 +21575,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAccelerationStructureGeometryKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureGeometryKHR*>( this ); @@ -21013,15 +21586,25 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureGeometryKHR*>( this ); } + + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::GeometryTypeKHR geometryType = VULKAN_HPP_NAMESPACE::GeometryTypeKHR::eTriangles; VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR geometry = {}; VULKAN_HPP_NAMESPACE::GeometryFlagsKHR flags = {}; + }; static_assert( sizeof( AccelerationStructureGeometryKHR ) == sizeof( VkAccelerationStructureGeometryKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureGeometryKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eAccelerationStructureGeometryKHR> + { + using Type = AccelerationStructureGeometryKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS @@ -21033,14 +21616,12 @@ namespace VULKAN_HPP_NAMESPACE } DeviceOrHostAddressKHR( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ = {} ) - { - deviceAddress = deviceAddress_; - } + : deviceAddress( deviceAddress_ ) + {} DeviceOrHostAddressKHR( void* hostAddress_ ) - { - hostAddress = hostAddress_; - } + : hostAddress( hostAddress_ ) + {} DeviceOrHostAddressKHR & setDeviceAddress( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ ) VULKAN_HPP_NOEXCEPT { @@ -21083,6 +21664,8 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureBuildGeometryInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureBuildGeometryInfoKHR; + AccelerationStructureBuildGeometryInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR type_ = VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR::eTopLevel, VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsKHR flags_ = {}, VULKAN_HPP_NAMESPACE::Bool32 update_ = {}, @@ -21174,12 +21757,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - AccelerationStructureBuildGeometryInfoKHR & setScratchData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR scratchData_ ) VULKAN_HPP_NOEXCEPT + AccelerationStructureBuildGeometryInfoKHR & setScratchData( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR const & scratchData_ ) VULKAN_HPP_NOEXCEPT { scratchData = scratchData_; return *this; } + operator VkAccelerationStructureBuildGeometryInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR*>( this ); @@ -21190,6 +21774,9 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR*>( this ); } + + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureBuildGeometryInfoKHR; const void* pNext = {}; @@ -21202,14 +21789,22 @@ namespace VULKAN_HPP_NAMESPACE uint32_t geometryCount = {}; const VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR* const* ppGeometries = {}; VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR scratchData = {}; + }; static_assert( sizeof( AccelerationStructureBuildGeometryInfoKHR ) == sizeof( VkAccelerationStructureBuildGeometryInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureBuildGeometryInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eAccelerationStructureBuildGeometryInfoKHR> + { + using Type = AccelerationStructureBuildGeometryInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureBuildOffsetInfoKHR { + VULKAN_HPP_CONSTEXPR AccelerationStructureBuildOffsetInfoKHR( uint32_t primitiveCount_ = {}, uint32_t primitiveOffset_ = {}, uint32_t firstVertex_ = {}, @@ -21255,6 +21850,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAccelerationStructureBuildOffsetInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureBuildOffsetInfoKHR*>( this ); @@ -21265,6 +21861,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureBuildOffsetInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AccelerationStructureBuildOffsetInfoKHR const& ) const = default; #else @@ -21282,11 +21879,14 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t primitiveCount = {}; uint32_t primitiveOffset = {}; uint32_t firstVertex = {}; uint32_t transformOffset = {}; + }; static_assert( sizeof( AccelerationStructureBuildOffsetInfoKHR ) == sizeof( VkAccelerationStructureBuildOffsetInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureBuildOffsetInfoKHR>::value, "struct wrapper is not a standard layout!" ); @@ -21295,6 +21895,8 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureCreateGeometryTypeInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureCreateGeometryTypeInfoKHR; + VULKAN_HPP_CONSTEXPR AccelerationStructureCreateGeometryTypeInfoKHR( VULKAN_HPP_NAMESPACE::GeometryTypeKHR geometryType_ = VULKAN_HPP_NAMESPACE::GeometryTypeKHR::eTriangles, uint32_t maxPrimitiveCount_ = {}, VULKAN_HPP_NAMESPACE::IndexType indexType_ = VULKAN_HPP_NAMESPACE::IndexType::eUint16, @@ -21368,6 +21970,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAccelerationStructureCreateGeometryTypeInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureCreateGeometryTypeInfoKHR*>( this ); @@ -21378,6 +21981,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureCreateGeometryTypeInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AccelerationStructureCreateGeometryTypeInfoKHR const& ) const = default; #else @@ -21399,6 +22003,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureCreateGeometryTypeInfoKHR; const void* pNext = {}; @@ -21408,14 +22014,23 @@ namespace VULKAN_HPP_NAMESPACE uint32_t maxVertexCount = {}; VULKAN_HPP_NAMESPACE::Format vertexFormat = VULKAN_HPP_NAMESPACE::Format::eUndefined; VULKAN_HPP_NAMESPACE::Bool32 allowsTransforms = {}; + }; static_assert( sizeof( AccelerationStructureCreateGeometryTypeInfoKHR ) == sizeof( VkAccelerationStructureCreateGeometryTypeInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureCreateGeometryTypeInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eAccelerationStructureCreateGeometryTypeInfoKHR> + { + using Type = AccelerationStructureCreateGeometryTypeInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureCreateInfoKHR; + VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoKHR( VULKAN_HPP_NAMESPACE::DeviceSize compactedSize_ = {}, VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR type_ = VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR::eTopLevel, VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsKHR flags_ = {}, @@ -21489,6 +22104,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAccelerationStructureCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureCreateInfoKHR*>( this ); @@ -21499,6 +22115,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AccelerationStructureCreateInfoKHR const& ) const = default; #else @@ -21520,6 +22137,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureCreateInfoKHR; const void* pNext = {}; @@ -21529,13 +22148,22 @@ namespace VULKAN_HPP_NAMESPACE uint32_t maxGeometryCount = {}; const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateGeometryTypeInfoKHR* pGeometryInfos = {}; VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress = {}; + }; static_assert( sizeof( AccelerationStructureCreateInfoKHR ) == sizeof( VkAccelerationStructureCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eAccelerationStructureCreateInfoKHR> + { + using Type = AccelerationStructureCreateInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct GeometryTrianglesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryTrianglesNV; + VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( VULKAN_HPP_NAMESPACE::Buffer vertexData_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize vertexOffset_ = {}, uint32_t vertexCount_ = {}, @@ -21649,6 +22277,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkGeometryTrianglesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkGeometryTrianglesNV*>( this ); @@ -21659,6 +22288,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkGeometryTrianglesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( GeometryTrianglesNV const& ) const = default; #else @@ -21685,6 +22315,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGeometryTrianglesNV; const void* pNext = {}; @@ -21699,12 +22331,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::IndexType indexType = VULKAN_HPP_NAMESPACE::IndexType::eUint16; VULKAN_HPP_NAMESPACE::Buffer transformData = {}; VULKAN_HPP_NAMESPACE::DeviceSize transformOffset = {}; + }; static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<GeometryTrianglesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eGeometryTrianglesNV> + { + using Type = GeometryTrianglesNV; + }; + struct GeometryAABBNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryAabbNV; + VULKAN_HPP_CONSTEXPR GeometryAABBNV( VULKAN_HPP_NAMESPACE::Buffer aabbData_ = {}, uint32_t numAABBs_ = {}, uint32_t stride_ = {}, @@ -21762,6 +22403,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkGeometryAABBNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkGeometryAABBNV*>( this ); @@ -21772,6 +22414,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkGeometryAABBNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( GeometryAABBNV const& ) const = default; #else @@ -21791,6 +22434,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGeometryAabbNV; const void* pNext = {}; @@ -21798,12 +22443,20 @@ namespace VULKAN_HPP_NAMESPACE uint32_t numAABBs = {}; uint32_t stride = {}; VULKAN_HPP_NAMESPACE::DeviceSize offset = {}; + }; static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<GeometryAABBNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eGeometryAabbNV> + { + using Type = GeometryAABBNV; + }; + struct GeometryDataNV { + VULKAN_HPP_CONSTEXPR GeometryDataNV( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV triangles_ = {}, VULKAN_HPP_NAMESPACE::GeometryAABBNV aabbs_ = {} ) VULKAN_HPP_NOEXCEPT : triangles( triangles_ ) @@ -21821,18 +22474,19 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - GeometryDataNV & setTriangles( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV triangles_ ) VULKAN_HPP_NOEXCEPT + GeometryDataNV & setTriangles( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & triangles_ ) VULKAN_HPP_NOEXCEPT { triangles = triangles_; return *this; } - GeometryDataNV & setAabbs( VULKAN_HPP_NAMESPACE::GeometryAABBNV aabbs_ ) VULKAN_HPP_NOEXCEPT + GeometryDataNV & setAabbs( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & aabbs_ ) VULKAN_HPP_NOEXCEPT { aabbs = aabbs_; return *this; } + operator VkGeometryDataNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkGeometryDataNV*>( this ); @@ -21843,6 +22497,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkGeometryDataNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( GeometryDataNV const& ) const = default; #else @@ -21858,15 +22513,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::GeometryTrianglesNV triangles = {}; VULKAN_HPP_NAMESPACE::GeometryAABBNV aabbs = {}; + }; static_assert( sizeof( GeometryDataNV ) == sizeof( VkGeometryDataNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<GeometryDataNV>::value, "struct wrapper is not a standard layout!" ); struct GeometryNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryNV; + VULKAN_HPP_CONSTEXPR GeometryNV( VULKAN_HPP_NAMESPACE::GeometryTypeKHR geometryType_ = VULKAN_HPP_NAMESPACE::GeometryTypeKHR::eTriangles, VULKAN_HPP_NAMESPACE::GeometryDataNV geometry_ = {}, VULKAN_HPP_NAMESPACE::GeometryFlagsKHR flags_ = {} ) VULKAN_HPP_NOEXCEPT @@ -21904,7 +22564,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - GeometryNV & setGeometry( VULKAN_HPP_NAMESPACE::GeometryDataNV geometry_ ) VULKAN_HPP_NOEXCEPT + GeometryNV & setGeometry( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometry_ ) VULKAN_HPP_NOEXCEPT { geometry = geometry_; return *this; @@ -21916,6 +22576,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkGeometryNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkGeometryNV*>( this ); @@ -21926,6 +22587,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkGeometryNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( GeometryNV const& ) const = default; #else @@ -21944,18 +22606,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGeometryNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::GeometryTypeKHR geometryType = VULKAN_HPP_NAMESPACE::GeometryTypeKHR::eTriangles; VULKAN_HPP_NAMESPACE::GeometryDataNV geometry = {}; VULKAN_HPP_NAMESPACE::GeometryFlagsKHR flags = {}; + }; static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<GeometryNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eGeometryNV> + { + using Type = GeometryNV; + }; + struct AccelerationStructureInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureInfoNV; + VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( VULKAN_HPP_NAMESPACE::AccelerationStructureTypeNV type_ = {}, VULKAN_HPP_NAMESPACE::BuildAccelerationStructureFlagsNV flags_ = {}, uint32_t instanceCount_ = {}, @@ -22021,6 +22694,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAccelerationStructureInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureInfoNV*>( this ); @@ -22031,6 +22705,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AccelerationStructureInfoNV const& ) const = default; #else @@ -22051,6 +22726,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureInfoNV; const void* pNext = {}; @@ -22059,12 +22736,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t instanceCount = {}; uint32_t geometryCount = {}; const VULKAN_HPP_NAMESPACE::GeometryNV* pGeometries = {}; + }; static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eAccelerationStructureInfoNV> + { + using Type = AccelerationStructureInfoNV; + }; + struct AccelerationStructureCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureCreateInfoNV; + VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( VULKAN_HPP_NAMESPACE::DeviceSize compactedSize_ = {}, VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV info_ = {} ) VULKAN_HPP_NOEXCEPT : compactedSize( compactedSize_ ) @@ -22100,12 +22786,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - AccelerationStructureCreateInfoNV & setInfo( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV info_ ) VULKAN_HPP_NOEXCEPT + AccelerationStructureCreateInfoNV & setInfo( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & info_ ) VULKAN_HPP_NOEXCEPT { info = info_; return *this; } + operator VkAccelerationStructureCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( this ); @@ -22116,6 +22803,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AccelerationStructureCreateInfoNV const& ) const = default; #else @@ -22133,18 +22821,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureCreateInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceSize compactedSize = {}; VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV info = {}; + }; static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eAccelerationStructureCreateInfoNV> + { + using Type = AccelerationStructureCreateInfoNV; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureDeviceAddressInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureDeviceAddressInfoKHR; + VULKAN_HPP_CONSTEXPR AccelerationStructureDeviceAddressInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT : accelerationStructure( accelerationStructure_ ) {} @@ -22178,6 +22877,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAccelerationStructureDeviceAddressInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR*>( this ); @@ -22188,6 +22888,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AccelerationStructureDeviceAddressInfoKHR const& ) const = default; #else @@ -22204,17 +22905,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureDeviceAddressInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure = {}; + }; static_assert( sizeof( AccelerationStructureDeviceAddressInfoKHR ) == sizeof( VkAccelerationStructureDeviceAddressInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureDeviceAddressInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eAccelerationStructureDeviceAddressInfoKHR> + { + using Type = AccelerationStructureDeviceAddressInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct TransformMatrixKHR { + VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR( std::array<std::array<float,4>,3> const& matrix_ = {} ) VULKAN_HPP_NOEXCEPT : matrix( matrix_ ) {} @@ -22236,6 +22947,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkTransformMatrixKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkTransformMatrixKHR*>( this ); @@ -22246,6 +22958,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkTransformMatrixKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( TransformMatrixKHR const& ) const = default; #else @@ -22260,14 +22973,18 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ArrayWrapper2D<float, 3, 4> matrix = {}; + }; static_assert( sizeof( TransformMatrixKHR ) == sizeof( VkTransformMatrixKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<TransformMatrixKHR>::value, "struct wrapper is not a standard layout!" ); struct AccelerationStructureInstanceKHR { + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR( VULKAN_HPP_NAMESPACE::TransformMatrixKHR transform_ = {}, uint32_t instanceCustomIndex_ = {}, uint32_t mask_ = {}, @@ -22293,7 +23010,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - AccelerationStructureInstanceKHR & setTransform( VULKAN_HPP_NAMESPACE::TransformMatrixKHR transform_ ) VULKAN_HPP_NOEXCEPT + AccelerationStructureInstanceKHR & setTransform( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transform_ ) VULKAN_HPP_NOEXCEPT { transform = transform_; return *this; @@ -22329,6 +23046,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAccelerationStructureInstanceKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureInstanceKHR*>( this ); @@ -22339,6 +23057,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureInstanceKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AccelerationStructureInstanceKHR const& ) const = default; #else @@ -22358,6 +23077,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::TransformMatrixKHR transform = {}; uint32_t instanceCustomIndex : 24; @@ -22365,6 +23086,7 @@ namespace VULKAN_HPP_NAMESPACE uint32_t instanceShaderBindingTableRecordOffset : 24; VkGeometryInstanceFlagsKHR flags : 8; uint64_t accelerationStructureReference = {}; + }; static_assert( sizeof( AccelerationStructureInstanceKHR ) == sizeof( VkAccelerationStructureInstanceKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureInstanceKHR>::value, "struct wrapper is not a standard layout!" ); @@ -22372,6 +23094,8 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureMemoryRequirementsInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureMemoryRequirementsInfoKHR; + VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeKHR type_ = VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeKHR::eObject, VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType_ = VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR::eHost, VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT @@ -22421,6 +23145,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAccelerationStructureMemoryRequirementsInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoKHR*>( this ); @@ -22431,6 +23156,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AccelerationStructureMemoryRequirementsInfoKHR const& ) const = default; #else @@ -22449,19 +23175,30 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeKHR type = VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeKHR::eObject; VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType = VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR::eHost; VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure = {}; + }; static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoKHR ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureMemoryRequirementsInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eAccelerationStructureMemoryRequirementsInfoKHR> + { + using Type = AccelerationStructureMemoryRequirementsInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct AccelerationStructureMemoryRequirementsInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV; + VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV type_ = {}, VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT : type( type_ ) @@ -22503,6 +23240,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAccelerationStructureMemoryRequirementsInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( this ); @@ -22513,6 +23251,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AccelerationStructureMemoryRequirementsInfoNV const& ) const = default; #else @@ -22530,18 +23269,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV type = {}; VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure = {}; + }; static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureMemoryRequirementsInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eAccelerationStructureMemoryRequirementsInfoNV> + { + using Type = AccelerationStructureMemoryRequirementsInfoNV; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct AccelerationStructureVersionKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureVersionKHR; + VULKAN_HPP_CONSTEXPR AccelerationStructureVersionKHR( const uint8_t* versionData_ = {} ) VULKAN_HPP_NOEXCEPT : versionData( versionData_ ) {} @@ -22575,6 +23325,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAccelerationStructureVersionKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAccelerationStructureVersionKHR*>( this ); @@ -22585,6 +23336,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAccelerationStructureVersionKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AccelerationStructureVersionKHR const& ) const = default; #else @@ -22601,17 +23353,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureVersionKHR; const void* pNext = {}; const uint8_t* versionData = {}; + }; static_assert( sizeof( AccelerationStructureVersionKHR ) == sizeof( VkAccelerationStructureVersionKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AccelerationStructureVersionKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eAccelerationStructureVersionKHR> + { + using Type = AccelerationStructureVersionKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct AcquireNextImageInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAcquireNextImageInfoKHR; + VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain_ = {}, uint64_t timeout_ = {}, VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {}, @@ -22677,6 +23440,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAcquireNextImageInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAcquireNextImageInfoKHR*>( this ); @@ -22687,6 +23451,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAcquireNextImageInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AcquireNextImageInfoKHR const& ) const = default; #else @@ -22707,6 +23472,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAcquireNextImageInfoKHR; const void* pNext = {}; @@ -22715,12 +23482,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Semaphore semaphore = {}; VULKAN_HPP_NAMESPACE::Fence fence = {}; uint32_t deviceMask = {}; + }; static_assert( sizeof( AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AcquireNextImageInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eAcquireNextImageInfoKHR> + { + using Type = AcquireNextImageInfoKHR; + }; + struct AcquireProfilingLockInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAcquireProfilingLockInfoKHR; + VULKAN_HPP_CONSTEXPR AcquireProfilingLockInfoKHR( VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR flags_ = {}, uint64_t timeout_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -22762,6 +23538,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAcquireProfilingLockInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAcquireProfilingLockInfoKHR*>( this ); @@ -22772,6 +23549,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAcquireProfilingLockInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AcquireProfilingLockInfoKHR const& ) const = default; #else @@ -22789,17 +23567,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAcquireProfilingLockInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR flags = {}; uint64_t timeout = {}; + }; static_assert( sizeof( AcquireProfilingLockInfoKHR ) == sizeof( VkAcquireProfilingLockInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AcquireProfilingLockInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eAcquireProfilingLockInfoKHR> + { + using Type = AcquireProfilingLockInfoKHR; + }; + struct AllocationCallbacks { + VULKAN_HPP_CONSTEXPR AllocationCallbacks( void* pUserData_ = {}, PFN_vkAllocationFunction pfnAllocation_ = {}, PFN_vkReallocationFunction pfnReallocation_ = {}, @@ -22861,6 +23649,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAllocationCallbacks const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAllocationCallbacks*>( this ); @@ -22871,6 +23660,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAllocationCallbacks*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AllocationCallbacks const& ) const = default; #else @@ -22890,6 +23680,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: void* pUserData = {}; PFN_vkAllocationFunction pfnAllocation = {}; @@ -22897,12 +23689,14 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkFreeFunction pfnFree = {}; PFN_vkInternalAllocationNotification pfnInternalAllocation = {}; PFN_vkInternalFreeNotification pfnInternalFree = {}; + }; static_assert( sizeof( AllocationCallbacks ) == sizeof( VkAllocationCallbacks ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AllocationCallbacks>::value, "struct wrapper is not a standard layout!" ); struct ComponentMapping { + VULKAN_HPP_CONSTEXPR ComponentMapping( VULKAN_HPP_NAMESPACE::ComponentSwizzle r_ = VULKAN_HPP_NAMESPACE::ComponentSwizzle::eIdentity, VULKAN_HPP_NAMESPACE::ComponentSwizzle g_ = VULKAN_HPP_NAMESPACE::ComponentSwizzle::eIdentity, VULKAN_HPP_NAMESPACE::ComponentSwizzle b_ = VULKAN_HPP_NAMESPACE::ComponentSwizzle::eIdentity, @@ -22948,6 +23742,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkComponentMapping const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkComponentMapping*>( this ); @@ -22958,6 +23753,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkComponentMapping*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ComponentMapping const& ) const = default; #else @@ -22975,11 +23771,14 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ComponentSwizzle r = VULKAN_HPP_NAMESPACE::ComponentSwizzle::eIdentity; VULKAN_HPP_NAMESPACE::ComponentSwizzle g = VULKAN_HPP_NAMESPACE::ComponentSwizzle::eIdentity; VULKAN_HPP_NAMESPACE::ComponentSwizzle b = VULKAN_HPP_NAMESPACE::ComponentSwizzle::eIdentity; VULKAN_HPP_NAMESPACE::ComponentSwizzle a = VULKAN_HPP_NAMESPACE::ComponentSwizzle::eIdentity; + }; static_assert( sizeof( ComponentMapping ) == sizeof( VkComponentMapping ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ComponentMapping>::value, "struct wrapper is not a standard layout!" ); @@ -22987,6 +23786,8 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_ANDROID_KHR struct AndroidHardwareBufferFormatPropertiesANDROID { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID; + VULKAN_HPP_CONSTEXPR AndroidHardwareBufferFormatPropertiesANDROID( VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, uint64_t externalFormat_ = {}, VULKAN_HPP_NAMESPACE::FormatFeatureFlags formatFeatures_ = {}, @@ -23022,6 +23823,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAndroidHardwareBufferFormatPropertiesANDROID const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>( this ); @@ -23032,6 +23834,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AndroidHardwareBufferFormatPropertiesANDROID const& ) const = default; #else @@ -23055,6 +23858,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID; void* pNext = {}; @@ -23066,14 +23871,23 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::SamplerYcbcrRange suggestedYcbcrRange = VULKAN_HPP_NAMESPACE::SamplerYcbcrRange::eItuFull; VULKAN_HPP_NAMESPACE::ChromaLocation suggestedXChromaOffset = VULKAN_HPP_NAMESPACE::ChromaLocation::eCositedEven; VULKAN_HPP_NAMESPACE::ChromaLocation suggestedYChromaOffset = VULKAN_HPP_NAMESPACE::ChromaLocation::eCositedEven; + }; static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AndroidHardwareBufferFormatPropertiesANDROID>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eAndroidHardwareBufferFormatPropertiesANDROID> + { + using Type = AndroidHardwareBufferFormatPropertiesANDROID; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #ifdef VK_USE_PLATFORM_ANDROID_KHR struct AndroidHardwareBufferPropertiesANDROID { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferPropertiesANDROID; + VULKAN_HPP_CONSTEXPR AndroidHardwareBufferPropertiesANDROID( VULKAN_HPP_NAMESPACE::DeviceSize allocationSize_ = {}, uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT : allocationSize( allocationSize_ ) @@ -23097,6 +23911,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAndroidHardwareBufferPropertiesANDROID const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAndroidHardwareBufferPropertiesANDROID*>( this ); @@ -23107,6 +23922,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AndroidHardwareBufferPropertiesANDROID const& ) const = default; #else @@ -23124,19 +23940,30 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID; void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceSize allocationSize = {}; uint32_t memoryTypeBits = {}; + }; static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AndroidHardwareBufferPropertiesANDROID>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eAndroidHardwareBufferPropertiesANDROID> + { + using Type = AndroidHardwareBufferPropertiesANDROID; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #ifdef VK_USE_PLATFORM_ANDROID_KHR struct AndroidHardwareBufferUsageANDROID { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferUsageANDROID; + VULKAN_HPP_CONSTEXPR AndroidHardwareBufferUsageANDROID( uint64_t androidHardwareBufferUsage_ = {} ) VULKAN_HPP_NOEXCEPT : androidHardwareBufferUsage( androidHardwareBufferUsage_ ) {} @@ -23158,6 +23985,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAndroidHardwareBufferUsageANDROID const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>( this ); @@ -23168,6 +23996,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AndroidHardwareBufferUsageANDROID const& ) const = default; #else @@ -23184,18 +24013,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID; void* pNext = {}; uint64_t androidHardwareBufferUsage = {}; + }; static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AndroidHardwareBufferUsageANDROID>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eAndroidHardwareBufferUsageANDROID> + { + using Type = AndroidHardwareBufferUsageANDROID; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #ifdef VK_USE_PLATFORM_ANDROID_KHR struct AndroidSurfaceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidSurfaceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR flags_ = {}, struct ANativeWindow* window_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -23237,6 +24077,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAndroidSurfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( this ); @@ -23247,6 +24088,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AndroidSurfaceCreateInfoKHR const& ) const = default; #else @@ -23264,18 +24106,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR flags = {}; struct ANativeWindow* window = {}; + }; static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AndroidSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eAndroidSurfaceCreateInfoKHR> + { + using Type = AndroidSurfaceCreateInfoKHR; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ struct ApplicationInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eApplicationInfo; + VULKAN_HPP_CONSTEXPR ApplicationInfo( const char* pApplicationName_ = {}, uint32_t applicationVersion_ = {}, const char* pEngineName_ = {}, @@ -23341,6 +24194,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkApplicationInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkApplicationInfo*>( this ); @@ -23351,6 +24205,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkApplicationInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ApplicationInfo const& ) const = default; #else @@ -23371,6 +24226,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eApplicationInfo; const void* pNext = {}; @@ -23379,12 +24236,20 @@ namespace VULKAN_HPP_NAMESPACE const char* pEngineName = {}; uint32_t engineVersion = {}; uint32_t apiVersion = {}; + }; static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ApplicationInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eApplicationInfo> + { + using Type = ApplicationInfo; + }; + struct AttachmentDescription { + VULKAN_HPP_CONSTEXPR AttachmentDescription( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1, @@ -23470,6 +24335,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAttachmentDescription const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAttachmentDescription*>( this ); @@ -23480,6 +24346,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAttachmentDescription*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AttachmentDescription const& ) const = default; #else @@ -23502,6 +24369,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags flags = {}; VULKAN_HPP_NAMESPACE::Format format = VULKAN_HPP_NAMESPACE::Format::eUndefined; @@ -23512,12 +24381,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::AttachmentStoreOp stencilStoreOp = VULKAN_HPP_NAMESPACE::AttachmentStoreOp::eStore; VULKAN_HPP_NAMESPACE::ImageLayout initialLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined; VULKAN_HPP_NAMESPACE::ImageLayout finalLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined; + }; static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AttachmentDescription>::value, "struct wrapper is not a standard layout!" ); struct AttachmentDescription2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentDescription2; + VULKAN_HPP_CONSTEXPR AttachmentDescription2( VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1, @@ -23615,6 +24487,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAttachmentDescription2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAttachmentDescription2*>( this ); @@ -23625,6 +24498,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAttachmentDescription2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AttachmentDescription2 const& ) const = default; #else @@ -23649,6 +24523,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAttachmentDescription2; const void* pNext = {}; @@ -23661,12 +24537,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::AttachmentStoreOp stencilStoreOp = VULKAN_HPP_NAMESPACE::AttachmentStoreOp::eStore; VULKAN_HPP_NAMESPACE::ImageLayout initialLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined; VULKAN_HPP_NAMESPACE::ImageLayout finalLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined; + }; static_assert( sizeof( AttachmentDescription2 ) == sizeof( VkAttachmentDescription2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AttachmentDescription2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eAttachmentDescription2> + { + using Type = AttachmentDescription2; + }; + struct AttachmentDescriptionStencilLayout { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentDescriptionStencilLayout; + VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayout( VULKAN_HPP_NAMESPACE::ImageLayout stencilInitialLayout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined, VULKAN_HPP_NAMESPACE::ImageLayout stencilFinalLayout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT : stencilInitialLayout( stencilInitialLayout_ ) @@ -23708,6 +24593,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAttachmentDescriptionStencilLayout const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>( this ); @@ -23718,6 +24604,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAttachmentDescriptionStencilLayout*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AttachmentDescriptionStencilLayout const& ) const = default; #else @@ -23735,17 +24622,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAttachmentDescriptionStencilLayout; void* pNext = {}; VULKAN_HPP_NAMESPACE::ImageLayout stencilInitialLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined; VULKAN_HPP_NAMESPACE::ImageLayout stencilFinalLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined; + }; static_assert( sizeof( AttachmentDescriptionStencilLayout ) == sizeof( VkAttachmentDescriptionStencilLayout ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AttachmentDescriptionStencilLayout>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eAttachmentDescriptionStencilLayout> + { + using Type = AttachmentDescriptionStencilLayout; + }; + struct AttachmentReference { + VULKAN_HPP_CONSTEXPR AttachmentReference( uint32_t attachment_ = {}, VULKAN_HPP_NAMESPACE::ImageLayout layout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT : attachment( attachment_ ) @@ -23775,6 +24672,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAttachmentReference const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAttachmentReference*>( this ); @@ -23785,6 +24683,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAttachmentReference*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AttachmentReference const& ) const = default; #else @@ -23800,15 +24699,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t attachment = {}; VULKAN_HPP_NAMESPACE::ImageLayout layout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined; + }; static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AttachmentReference>::value, "struct wrapper is not a standard layout!" ); struct AttachmentReference2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentReference2; + VULKAN_HPP_CONSTEXPR AttachmentReference2( uint32_t attachment_ = {}, VULKAN_HPP_NAMESPACE::ImageLayout layout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined, VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {} ) VULKAN_HPP_NOEXCEPT @@ -23858,6 +24762,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAttachmentReference2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAttachmentReference2*>( this ); @@ -23868,6 +24773,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAttachmentReference2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AttachmentReference2 const& ) const = default; #else @@ -23886,18 +24792,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAttachmentReference2; const void* pNext = {}; uint32_t attachment = {}; VULKAN_HPP_NAMESPACE::ImageLayout layout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined; VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {}; + }; static_assert( sizeof( AttachmentReference2 ) == sizeof( VkAttachmentReference2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AttachmentReference2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eAttachmentReference2> + { + using Type = AttachmentReference2; + }; + struct AttachmentReferenceStencilLayout { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentReferenceStencilLayout; + VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayout( VULKAN_HPP_NAMESPACE::ImageLayout stencilLayout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT : stencilLayout( stencilLayout_ ) {} @@ -23931,6 +24848,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkAttachmentReferenceStencilLayout const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAttachmentReferenceStencilLayout*>( this ); @@ -23941,6 +24859,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAttachmentReferenceStencilLayout*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AttachmentReferenceStencilLayout const& ) const = default; #else @@ -23957,16 +24876,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAttachmentReferenceStencilLayout; void* pNext = {}; VULKAN_HPP_NAMESPACE::ImageLayout stencilLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined; + }; static_assert( sizeof( AttachmentReferenceStencilLayout ) == sizeof( VkAttachmentReferenceStencilLayout ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AttachmentReferenceStencilLayout>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eAttachmentReferenceStencilLayout> + { + using Type = AttachmentReferenceStencilLayout; + }; + struct Extent2D { + VULKAN_HPP_CONSTEXPR Extent2D( uint32_t width_ = {}, uint32_t height_ = {} ) VULKAN_HPP_NOEXCEPT : width( width_ ) @@ -23996,6 +24925,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExtent2D const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExtent2D*>( this ); @@ -24006,6 +24936,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExtent2D*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( Extent2D const& ) const = default; #else @@ -24021,15 +24952,19 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t width = {}; uint32_t height = {}; + }; static_assert( sizeof( Extent2D ) == sizeof( VkExtent2D ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<Extent2D>::value, "struct wrapper is not a standard layout!" ); struct SampleLocationEXT { + VULKAN_HPP_CONSTEXPR SampleLocationEXT( float x_ = {}, float y_ = {} ) VULKAN_HPP_NOEXCEPT : x( x_ ) @@ -24059,6 +24994,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSampleLocationEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSampleLocationEXT*>( this ); @@ -24069,6 +25005,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSampleLocationEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SampleLocationEXT const& ) const = default; #else @@ -24084,15 +25021,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: float x = {}; float y = {}; + }; static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SampleLocationEXT>::value, "struct wrapper is not a standard layout!" ); struct SampleLocationsInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSampleLocationsInfoEXT; + VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits sampleLocationsPerPixel_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1, VULKAN_HPP_NAMESPACE::Extent2D sampleLocationGridSize_ = {}, uint32_t sampleLocationsCount_ = {}, @@ -24132,7 +25074,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - SampleLocationsInfoEXT & setSampleLocationGridSize( VULKAN_HPP_NAMESPACE::Extent2D sampleLocationGridSize_ ) VULKAN_HPP_NOEXCEPT + SampleLocationsInfoEXT & setSampleLocationGridSize( VULKAN_HPP_NAMESPACE::Extent2D const & sampleLocationGridSize_ ) VULKAN_HPP_NOEXCEPT { sampleLocationGridSize = sampleLocationGridSize_; return *this; @@ -24150,6 +25092,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSampleLocationsInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSampleLocationsInfoEXT*>( this ); @@ -24160,6 +25103,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSampleLocationsInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SampleLocationsInfoEXT const& ) const = default; #else @@ -24179,6 +25123,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSampleLocationsInfoEXT; const void* pNext = {}; @@ -24186,12 +25132,20 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Extent2D sampleLocationGridSize = {}; uint32_t sampleLocationsCount = {}; const VULKAN_HPP_NAMESPACE::SampleLocationEXT* pSampleLocations = {}; + }; static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SampleLocationsInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSampleLocationsInfoEXT> + { + using Type = SampleLocationsInfoEXT; + }; + struct AttachmentSampleLocationsEXT { + VULKAN_HPP_CONSTEXPR AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = {}, VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ = {} ) VULKAN_HPP_NOEXCEPT : attachmentIndex( attachmentIndex_ ) @@ -24215,12 +25169,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - AttachmentSampleLocationsEXT & setSampleLocationsInfo( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ ) VULKAN_HPP_NOEXCEPT + AttachmentSampleLocationsEXT & setSampleLocationsInfo( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfo_ ) VULKAN_HPP_NOEXCEPT { sampleLocationsInfo = sampleLocationsInfo_; return *this; } + operator VkAttachmentSampleLocationsEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkAttachmentSampleLocationsEXT*>( this ); @@ -24231,6 +25186,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkAttachmentSampleLocationsEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( AttachmentSampleLocationsEXT const& ) const = default; #else @@ -24246,15 +25202,19 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t attachmentIndex = {}; VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo = {}; + }; static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<AttachmentSampleLocationsEXT>::value, "struct wrapper is not a standard layout!" ); struct BaseInStructure { + BaseInStructure() VULKAN_HPP_NOEXCEPT {} @@ -24275,6 +25235,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBaseInStructure const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBaseInStructure*>( this ); @@ -24285,6 +25246,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBaseInStructure*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BaseInStructure const& ) const = default; #else @@ -24300,15 +25262,19 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::StructureType sType = {}; const struct VULKAN_HPP_NAMESPACE::BaseInStructure* pNext = {}; + }; static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BaseInStructure>::value, "struct wrapper is not a standard layout!" ); struct BaseOutStructure { + BaseOutStructure() VULKAN_HPP_NOEXCEPT {} @@ -24329,6 +25295,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBaseOutStructure const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBaseOutStructure*>( this ); @@ -24339,6 +25306,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBaseOutStructure*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BaseOutStructure const& ) const = default; #else @@ -24354,15 +25322,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::StructureType sType = {}; struct VULKAN_HPP_NAMESPACE::BaseOutStructure* pNext = {}; + }; static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BaseOutStructure>::value, "struct wrapper is not a standard layout!" ); struct BindAccelerationStructureMemoryInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindAccelerationStructureMemoryInfoKHR; + VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure_ = {}, VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset_ = {}, @@ -24428,6 +25401,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBindAccelerationStructureMemoryInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBindAccelerationStructureMemoryInfoKHR*>( this ); @@ -24438,6 +25412,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBindAccelerationStructureMemoryInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BindAccelerationStructureMemoryInfoKHR const& ) const = default; #else @@ -24458,6 +25433,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoKHR; const void* pNext = {}; @@ -24466,12 +25443,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset = {}; uint32_t deviceIndexCount = {}; const uint32_t* pDeviceIndices = {}; + }; static_assert( sizeof( BindAccelerationStructureMemoryInfoKHR ) == sizeof( VkBindAccelerationStructureMemoryInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BindAccelerationStructureMemoryInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBindAccelerationStructureMemoryInfoKHR> + { + using Type = BindAccelerationStructureMemoryInfoKHR; + }; + struct BindBufferMemoryDeviceGroupInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindBufferMemoryDeviceGroupInfo; + VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = {}, const uint32_t* pDeviceIndices_ = {} ) VULKAN_HPP_NOEXCEPT : deviceIndexCount( deviceIndexCount_ ) @@ -24513,6 +25499,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBindBufferMemoryDeviceGroupInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>( this ); @@ -24523,6 +25510,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BindBufferMemoryDeviceGroupInfo const& ) const = default; #else @@ -24540,17 +25528,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo; const void* pNext = {}; uint32_t deviceIndexCount = {}; const uint32_t* pDeviceIndices = {}; + }; static_assert( sizeof( BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BindBufferMemoryDeviceGroupInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBindBufferMemoryDeviceGroupInfo> + { + using Type = BindBufferMemoryDeviceGroupInfo; + }; + struct BindBufferMemoryInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindBufferMemoryInfo; + VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {}, VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset_ = {} ) VULKAN_HPP_NOEXCEPT @@ -24600,6 +25599,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBindBufferMemoryInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBindBufferMemoryInfo*>( this ); @@ -24610,6 +25610,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBindBufferMemoryInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BindBufferMemoryInfo const& ) const = default; #else @@ -24628,18 +25629,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindBufferMemoryInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Buffer buffer = {}; VULKAN_HPP_NAMESPACE::DeviceMemory memory = {}; VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset = {}; + }; static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BindBufferMemoryInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBindBufferMemoryInfo> + { + using Type = BindBufferMemoryInfo; + }; + struct Offset2D { + VULKAN_HPP_CONSTEXPR Offset2D( int32_t x_ = {}, int32_t y_ = {} ) VULKAN_HPP_NOEXCEPT : x( x_ ) @@ -24669,6 +25680,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkOffset2D const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkOffset2D*>( this ); @@ -24679,6 +25691,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkOffset2D*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( Offset2D const& ) const = default; #else @@ -24694,15 +25707,19 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: int32_t x = {}; int32_t y = {}; + }; static_assert( sizeof( Offset2D ) == sizeof( VkOffset2D ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<Offset2D>::value, "struct wrapper is not a standard layout!" ); struct Rect2D { + VULKAN_HPP_CONSTEXPR Rect2D( VULKAN_HPP_NAMESPACE::Offset2D offset_ = {}, VULKAN_HPP_NAMESPACE::Extent2D extent_ = {} ) VULKAN_HPP_NOEXCEPT : offset( offset_ ) @@ -24720,18 +25737,19 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - Rect2D & setOffset( VULKAN_HPP_NAMESPACE::Offset2D offset_ ) VULKAN_HPP_NOEXCEPT + Rect2D & setOffset( VULKAN_HPP_NAMESPACE::Offset2D const & offset_ ) VULKAN_HPP_NOEXCEPT { offset = offset_; return *this; } - Rect2D & setExtent( VULKAN_HPP_NAMESPACE::Extent2D extent_ ) VULKAN_HPP_NOEXCEPT + Rect2D & setExtent( VULKAN_HPP_NAMESPACE::Extent2D const & extent_ ) VULKAN_HPP_NOEXCEPT { extent = extent_; return *this; } + operator VkRect2D const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRect2D*>( this ); @@ -24742,6 +25760,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRect2D*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( Rect2D const& ) const = default; #else @@ -24757,15 +25776,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Offset2D offset = {}; VULKAN_HPP_NAMESPACE::Extent2D extent = {}; + }; static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<Rect2D>::value, "struct wrapper is not a standard layout!" ); struct BindImageMemoryDeviceGroupInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemoryDeviceGroupInfo; + VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = {}, const uint32_t* pDeviceIndices_ = {}, uint32_t splitInstanceBindRegionCount_ = {}, @@ -24823,6 +25847,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBindImageMemoryDeviceGroupInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>( this ); @@ -24833,6 +25858,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BindImageMemoryDeviceGroupInfo const& ) const = default; #else @@ -24852,6 +25878,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo; const void* pNext = {}; @@ -24859,12 +25887,21 @@ namespace VULKAN_HPP_NAMESPACE const uint32_t* pDeviceIndices = {}; uint32_t splitInstanceBindRegionCount = {}; const VULKAN_HPP_NAMESPACE::Rect2D* pSplitInstanceBindRegions = {}; + }; static_assert( sizeof( BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BindImageMemoryDeviceGroupInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBindImageMemoryDeviceGroupInfo> + { + using Type = BindImageMemoryDeviceGroupInfo; + }; + struct BindImageMemoryInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemoryInfo; + VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( VULKAN_HPP_NAMESPACE::Image image_ = {}, VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset_ = {} ) VULKAN_HPP_NOEXCEPT @@ -24914,6 +25951,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBindImageMemoryInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBindImageMemoryInfo*>( this ); @@ -24924,6 +25962,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBindImageMemoryInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BindImageMemoryInfo const& ) const = default; #else @@ -24942,18 +25981,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindImageMemoryInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Image image = {}; VULKAN_HPP_NAMESPACE::DeviceMemory memory = {}; VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset = {}; + }; static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BindImageMemoryInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBindImageMemoryInfo> + { + using Type = BindImageMemoryInfo; + }; + struct BindImageMemorySwapchainInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemorySwapchainInfoKHR; + VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain_ = {}, uint32_t imageIndex_ = {} ) VULKAN_HPP_NOEXCEPT : swapchain( swapchain_ ) @@ -24995,6 +26045,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBindImageMemorySwapchainInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>( this ); @@ -25005,6 +26056,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BindImageMemorySwapchainInfoKHR const& ) const = default; #else @@ -25022,17 +26074,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain = {}; uint32_t imageIndex = {}; + }; static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BindImageMemorySwapchainInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBindImageMemorySwapchainInfoKHR> + { + using Type = BindImageMemorySwapchainInfoKHR; + }; + struct BindImagePlaneMemoryInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImagePlaneMemoryInfo; + VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( VULKAN_HPP_NAMESPACE::ImageAspectFlagBits planeAspect_ = VULKAN_HPP_NAMESPACE::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT : planeAspect( planeAspect_ ) {} @@ -25066,6 +26129,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBindImagePlaneMemoryInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBindImagePlaneMemoryInfo*>( this ); @@ -25076,6 +26140,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBindImagePlaneMemoryInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BindImagePlaneMemoryInfo const& ) const = default; #else @@ -25092,16 +26157,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindImagePlaneMemoryInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ImageAspectFlagBits planeAspect = VULKAN_HPP_NAMESPACE::ImageAspectFlagBits::eColor; + }; static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BindImagePlaneMemoryInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBindImagePlaneMemoryInfo> + { + using Type = BindImagePlaneMemoryInfo; + }; + struct BindIndexBufferIndirectCommandNV { + VULKAN_HPP_CONSTEXPR BindIndexBufferIndirectCommandNV( VULKAN_HPP_NAMESPACE::DeviceAddress bufferAddress_ = {}, uint32_t size_ = {}, VULKAN_HPP_NAMESPACE::IndexType indexType_ = VULKAN_HPP_NAMESPACE::IndexType::eUint16 ) VULKAN_HPP_NOEXCEPT @@ -25139,6 +26214,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBindIndexBufferIndirectCommandNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBindIndexBufferIndirectCommandNV*>( this ); @@ -25149,6 +26225,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBindIndexBufferIndirectCommandNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BindIndexBufferIndirectCommandNV const& ) const = default; #else @@ -25165,16 +26242,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::DeviceAddress bufferAddress = {}; uint32_t size = {}; VULKAN_HPP_NAMESPACE::IndexType indexType = VULKAN_HPP_NAMESPACE::IndexType::eUint16; + }; static_assert( sizeof( BindIndexBufferIndirectCommandNV ) == sizeof( VkBindIndexBufferIndirectCommandNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BindIndexBufferIndirectCommandNV>::value, "struct wrapper is not a standard layout!" ); struct BindShaderGroupIndirectCommandNV { + VULKAN_HPP_CONSTEXPR BindShaderGroupIndirectCommandNV( uint32_t groupIndex_ = {} ) VULKAN_HPP_NOEXCEPT : groupIndex( groupIndex_ ) {} @@ -25196,6 +26277,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBindShaderGroupIndirectCommandNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBindShaderGroupIndirectCommandNV*>( this ); @@ -25206,6 +26288,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBindShaderGroupIndirectCommandNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BindShaderGroupIndirectCommandNV const& ) const = default; #else @@ -25220,14 +26303,18 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t groupIndex = {}; + }; static_assert( sizeof( BindShaderGroupIndirectCommandNV ) == sizeof( VkBindShaderGroupIndirectCommandNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BindShaderGroupIndirectCommandNV>::value, "struct wrapper is not a standard layout!" ); struct SparseMemoryBind { + VULKAN_HPP_CONSTEXPR SparseMemoryBind( VULKAN_HPP_NAMESPACE::DeviceSize resourceOffset_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize size_ = {}, VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, @@ -25281,6 +26368,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSparseMemoryBind const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSparseMemoryBind*>( this ); @@ -25291,6 +26379,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSparseMemoryBind*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SparseMemoryBind const& ) const = default; #else @@ -25309,18 +26398,22 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::DeviceSize resourceOffset = {}; VULKAN_HPP_NAMESPACE::DeviceSize size = {}; VULKAN_HPP_NAMESPACE::DeviceMemory memory = {}; VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset = {}; VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags flags = {}; + }; static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SparseMemoryBind>::value, "struct wrapper is not a standard layout!" ); struct SparseBufferMemoryBindInfo { + VULKAN_HPP_CONSTEXPR SparseBufferMemoryBindInfo( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {}, uint32_t bindCount_ = {}, const VULKAN_HPP_NAMESPACE::SparseMemoryBind* pBinds_ = {} ) VULKAN_HPP_NOEXCEPT @@ -25358,6 +26451,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSparseBufferMemoryBindInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSparseBufferMemoryBindInfo*>( this ); @@ -25368,6 +26462,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSparseBufferMemoryBindInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SparseBufferMemoryBindInfo const& ) const = default; #else @@ -25384,16 +26479,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Buffer buffer = {}; uint32_t bindCount = {}; const VULKAN_HPP_NAMESPACE::SparseMemoryBind* pBinds = {}; + }; static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SparseBufferMemoryBindInfo>::value, "struct wrapper is not a standard layout!" ); struct SparseImageOpaqueMemoryBindInfo { + VULKAN_HPP_CONSTEXPR SparseImageOpaqueMemoryBindInfo( VULKAN_HPP_NAMESPACE::Image image_ = {}, uint32_t bindCount_ = {}, const VULKAN_HPP_NAMESPACE::SparseMemoryBind* pBinds_ = {} ) VULKAN_HPP_NOEXCEPT @@ -25431,6 +26530,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSparseImageOpaqueMemoryBindInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo*>( this ); @@ -25441,6 +26541,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SparseImageOpaqueMemoryBindInfo const& ) const = default; #else @@ -25457,16 +26558,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Image image = {}; uint32_t bindCount = {}; const VULKAN_HPP_NAMESPACE::SparseMemoryBind* pBinds = {}; + }; static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SparseImageOpaqueMemoryBindInfo>::value, "struct wrapper is not a standard layout!" ); struct ImageSubresource { + VULKAN_HPP_CONSTEXPR ImageSubresource( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {}, uint32_t mipLevel_ = {}, uint32_t arrayLayer_ = {} ) VULKAN_HPP_NOEXCEPT @@ -25504,6 +26609,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageSubresource const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageSubresource*>( this ); @@ -25514,6 +26620,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageSubresource*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageSubresource const& ) const = default; #else @@ -25530,16 +26637,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {}; uint32_t mipLevel = {}; uint32_t arrayLayer = {}; + }; static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageSubresource>::value, "struct wrapper is not a standard layout!" ); struct Offset3D { + VULKAN_HPP_CONSTEXPR Offset3D( int32_t x_ = {}, int32_t y_ = {}, int32_t z_ = {} ) VULKAN_HPP_NOEXCEPT @@ -25584,6 +26695,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkOffset3D const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkOffset3D*>( this ); @@ -25594,6 +26706,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkOffset3D*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( Offset3D const& ) const = default; #else @@ -25610,16 +26723,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: int32_t x = {}; int32_t y = {}; int32_t z = {}; + }; static_assert( sizeof( Offset3D ) == sizeof( VkOffset3D ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<Offset3D>::value, "struct wrapper is not a standard layout!" ); struct Extent3D { + VULKAN_HPP_CONSTEXPR Extent3D( uint32_t width_ = {}, uint32_t height_ = {}, uint32_t depth_ = {} ) VULKAN_HPP_NOEXCEPT @@ -25664,6 +26781,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExtent3D const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExtent3D*>( this ); @@ -25674,6 +26792,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExtent3D*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( Extent3D const& ) const = default; #else @@ -25690,16 +26809,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t width = {}; uint32_t height = {}; uint32_t depth = {}; + }; static_assert( sizeof( Extent3D ) == sizeof( VkExtent3D ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<Extent3D>::value, "struct wrapper is not a standard layout!" ); struct SparseImageMemoryBind { + VULKAN_HPP_CONSTEXPR SparseImageMemoryBind( VULKAN_HPP_NAMESPACE::ImageSubresource subresource_ = {}, VULKAN_HPP_NAMESPACE::Offset3D offset_ = {}, VULKAN_HPP_NAMESPACE::Extent3D extent_ = {}, @@ -25725,19 +26848,19 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - SparseImageMemoryBind & setSubresource( VULKAN_HPP_NAMESPACE::ImageSubresource subresource_ ) VULKAN_HPP_NOEXCEPT + SparseImageMemoryBind & setSubresource( VULKAN_HPP_NAMESPACE::ImageSubresource const & subresource_ ) VULKAN_HPP_NOEXCEPT { subresource = subresource_; return *this; } - SparseImageMemoryBind & setOffset( VULKAN_HPP_NAMESPACE::Offset3D offset_ ) VULKAN_HPP_NOEXCEPT + SparseImageMemoryBind & setOffset( VULKAN_HPP_NAMESPACE::Offset3D const & offset_ ) VULKAN_HPP_NOEXCEPT { offset = offset_; return *this; } - SparseImageMemoryBind & setExtent( VULKAN_HPP_NAMESPACE::Extent3D extent_ ) VULKAN_HPP_NOEXCEPT + SparseImageMemoryBind & setExtent( VULKAN_HPP_NAMESPACE::Extent3D const & extent_ ) VULKAN_HPP_NOEXCEPT { extent = extent_; return *this; @@ -25761,6 +26884,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSparseImageMemoryBind const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSparseImageMemoryBind*>( this ); @@ -25771,6 +26895,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSparseImageMemoryBind*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SparseImageMemoryBind const& ) const = default; #else @@ -25790,6 +26915,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ImageSubresource subresource = {}; VULKAN_HPP_NAMESPACE::Offset3D offset = {}; @@ -25797,12 +26924,14 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeviceMemory memory = {}; VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset = {}; VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags flags = {}; + }; static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SparseImageMemoryBind>::value, "struct wrapper is not a standard layout!" ); struct SparseImageMemoryBindInfo { + VULKAN_HPP_CONSTEXPR SparseImageMemoryBindInfo( VULKAN_HPP_NAMESPACE::Image image_ = {}, uint32_t bindCount_ = {}, const VULKAN_HPP_NAMESPACE::SparseImageMemoryBind* pBinds_ = {} ) VULKAN_HPP_NOEXCEPT @@ -25840,6 +26969,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSparseImageMemoryBindInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSparseImageMemoryBindInfo*>( this ); @@ -25850,6 +26980,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSparseImageMemoryBindInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SparseImageMemoryBindInfo const& ) const = default; #else @@ -25866,16 +26997,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Image image = {}; uint32_t bindCount = {}; const VULKAN_HPP_NAMESPACE::SparseImageMemoryBind* pBinds = {}; + }; static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SparseImageMemoryBindInfo>::value, "struct wrapper is not a standard layout!" ); struct BindSparseInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindSparseInfo; + VULKAN_HPP_CONSTEXPR BindSparseInfo( uint32_t waitSemaphoreCount_ = {}, const VULKAN_HPP_NAMESPACE::Semaphore* pWaitSemaphores_ = {}, uint32_t bufferBindCount_ = {}, @@ -25981,6 +27117,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBindSparseInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBindSparseInfo*>( this ); @@ -25991,6 +27128,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBindSparseInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BindSparseInfo const& ) const = default; #else @@ -26016,6 +27154,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBindSparseInfo; const void* pNext = {}; @@ -26029,12 +27169,20 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo* pImageBinds = {}; uint32_t signalSemaphoreCount = {}; const VULKAN_HPP_NAMESPACE::Semaphore* pSignalSemaphores = {}; + }; static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BindSparseInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBindSparseInfo> + { + using Type = BindSparseInfo; + }; + struct BindVertexBufferIndirectCommandNV { + VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandNV( VULKAN_HPP_NAMESPACE::DeviceAddress bufferAddress_ = {}, uint32_t size_ = {}, uint32_t stride_ = {} ) VULKAN_HPP_NOEXCEPT @@ -26072,6 +27220,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBindVertexBufferIndirectCommandNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBindVertexBufferIndirectCommandNV*>( this ); @@ -26082,6 +27231,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBindVertexBufferIndirectCommandNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BindVertexBufferIndirectCommandNV const& ) const = default; #else @@ -26098,16 +27248,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::DeviceAddress bufferAddress = {}; uint32_t size = {}; uint32_t stride = {}; + }; static_assert( sizeof( BindVertexBufferIndirectCommandNV ) == sizeof( VkBindVertexBufferIndirectCommandNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BindVertexBufferIndirectCommandNV>::value, "struct wrapper is not a standard layout!" ); struct BufferCopy { + VULKAN_HPP_CONSTEXPR BufferCopy( VULKAN_HPP_NAMESPACE::DeviceSize srcOffset_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT @@ -26145,6 +27299,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBufferCopy const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBufferCopy*>( this ); @@ -26155,6 +27310,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBufferCopy*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BufferCopy const& ) const = default; #else @@ -26171,16 +27327,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::DeviceSize srcOffset = {}; VULKAN_HPP_NAMESPACE::DeviceSize dstOffset = {}; VULKAN_HPP_NAMESPACE::DeviceSize size = {}; + }; static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BufferCopy>::value, "struct wrapper is not a standard layout!" ); struct BufferCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCreateInfo; + VULKAN_HPP_CONSTEXPR BufferCreateInfo( VULKAN_HPP_NAMESPACE::BufferCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize size_ = {}, VULKAN_HPP_NAMESPACE::BufferUsageFlags usage_ = {}, @@ -26254,6 +27415,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBufferCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBufferCreateInfo*>( this ); @@ -26264,6 +27426,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBufferCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BufferCreateInfo const& ) const = default; #else @@ -26285,6 +27448,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBufferCreateInfo; const void* pNext = {}; @@ -26294,12 +27459,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::SharingMode sharingMode = VULKAN_HPP_NAMESPACE::SharingMode::eExclusive; uint32_t queueFamilyIndexCount = {}; const uint32_t* pQueueFamilyIndices = {}; + }; static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BufferCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBufferCreateInfo> + { + using Type = BufferCreateInfo; + }; + struct BufferDeviceAddressCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferDeviceAddressCreateInfoEXT; + VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ = {} ) VULKAN_HPP_NOEXCEPT : deviceAddress( deviceAddress_ ) {} @@ -26333,6 +27507,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBufferDeviceAddressCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>( this ); @@ -26343,6 +27518,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BufferDeviceAddressCreateInfoEXT const& ) const = default; #else @@ -26359,16 +27535,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress = {}; + }; static_assert( sizeof( BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BufferDeviceAddressCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBufferDeviceAddressCreateInfoEXT> + { + using Type = BufferDeviceAddressCreateInfoEXT; + }; + struct BufferDeviceAddressInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferDeviceAddressInfo; + VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfo( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {} ) VULKAN_HPP_NOEXCEPT : buffer( buffer_ ) {} @@ -26402,6 +27589,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBufferDeviceAddressInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBufferDeviceAddressInfo*>( this ); @@ -26412,6 +27600,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBufferDeviceAddressInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BufferDeviceAddressInfo const& ) const = default; #else @@ -26428,16 +27617,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBufferDeviceAddressInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Buffer buffer = {}; + }; static_assert( sizeof( BufferDeviceAddressInfo ) == sizeof( VkBufferDeviceAddressInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BufferDeviceAddressInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBufferDeviceAddressInfo> + { + using Type = BufferDeviceAddressInfo; + }; + struct ImageSubresourceLayers { + VULKAN_HPP_CONSTEXPR ImageSubresourceLayers( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {}, uint32_t mipLevel_ = {}, uint32_t baseArrayLayer_ = {}, @@ -26483,6 +27682,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageSubresourceLayers const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageSubresourceLayers*>( this ); @@ -26493,6 +27693,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageSubresourceLayers*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageSubresourceLayers const& ) const = default; #else @@ -26510,17 +27711,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {}; uint32_t mipLevel = {}; uint32_t baseArrayLayer = {}; uint32_t layerCount = {}; + }; static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageSubresourceLayers>::value, "struct wrapper is not a standard layout!" ); struct BufferImageCopy { + VULKAN_HPP_CONSTEXPR BufferImageCopy( VULKAN_HPP_NAMESPACE::DeviceSize bufferOffset_ = {}, uint32_t bufferRowLength_ = {}, uint32_t bufferImageHeight_ = {}, @@ -26564,24 +27769,25 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - BufferImageCopy & setImageSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers imageSubresource_ ) VULKAN_HPP_NOEXCEPT + BufferImageCopy & setImageSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresource_ ) VULKAN_HPP_NOEXCEPT { imageSubresource = imageSubresource_; return *this; } - BufferImageCopy & setImageOffset( VULKAN_HPP_NAMESPACE::Offset3D imageOffset_ ) VULKAN_HPP_NOEXCEPT + BufferImageCopy & setImageOffset( VULKAN_HPP_NAMESPACE::Offset3D const & imageOffset_ ) VULKAN_HPP_NOEXCEPT { imageOffset = imageOffset_; return *this; } - BufferImageCopy & setImageExtent( VULKAN_HPP_NAMESPACE::Extent3D imageExtent_ ) VULKAN_HPP_NOEXCEPT + BufferImageCopy & setImageExtent( VULKAN_HPP_NAMESPACE::Extent3D const & imageExtent_ ) VULKAN_HPP_NOEXCEPT { imageExtent = imageExtent_; return *this; } + operator VkBufferImageCopy const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBufferImageCopy*>( this ); @@ -26592,6 +27798,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBufferImageCopy*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BufferImageCopy const& ) const = default; #else @@ -26611,6 +27818,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::DeviceSize bufferOffset = {}; uint32_t bufferRowLength = {}; @@ -26618,12 +27827,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ImageSubresourceLayers imageSubresource = {}; VULKAN_HPP_NAMESPACE::Offset3D imageOffset = {}; VULKAN_HPP_NAMESPACE::Extent3D imageExtent = {}; + }; static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BufferImageCopy>::value, "struct wrapper is not a standard layout!" ); struct BufferMemoryBarrier { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferMemoryBarrier; + VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask_ = {}, VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask_ = {}, uint32_t srcQueueFamilyIndex_ = {}, @@ -26705,6 +27917,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBufferMemoryBarrier const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBufferMemoryBarrier*>( this ); @@ -26715,6 +27928,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBufferMemoryBarrier*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BufferMemoryBarrier const& ) const = default; #else @@ -26737,6 +27951,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBufferMemoryBarrier; const void* pNext = {}; @@ -26747,12 +27963,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Buffer buffer = {}; VULKAN_HPP_NAMESPACE::DeviceSize offset = {}; VULKAN_HPP_NAMESPACE::DeviceSize size = {}; + }; static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BufferMemoryBarrier>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBufferMemoryBarrier> + { + using Type = BufferMemoryBarrier; + }; + struct BufferMemoryRequirementsInfo2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferMemoryRequirementsInfo2; + VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {} ) VULKAN_HPP_NOEXCEPT : buffer( buffer_ ) {} @@ -26786,6 +28011,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBufferMemoryRequirementsInfo2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( this ); @@ -26796,6 +28022,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBufferMemoryRequirementsInfo2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BufferMemoryRequirementsInfo2 const& ) const = default; #else @@ -26812,16 +28039,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBufferMemoryRequirementsInfo2; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Buffer buffer = {}; + }; static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BufferMemoryRequirementsInfo2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBufferMemoryRequirementsInfo2> + { + using Type = BufferMemoryRequirementsInfo2; + }; + struct BufferOpaqueCaptureAddressCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferOpaqueCaptureAddressCreateInfo; + VULKAN_HPP_CONSTEXPR BufferOpaqueCaptureAddressCreateInfo( uint64_t opaqueCaptureAddress_ = {} ) VULKAN_HPP_NOEXCEPT : opaqueCaptureAddress( opaqueCaptureAddress_ ) {} @@ -26855,6 +28093,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBufferOpaqueCaptureAddressCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>( this ); @@ -26865,6 +28104,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BufferOpaqueCaptureAddressCreateInfo const& ) const = default; #else @@ -26881,16 +28121,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBufferOpaqueCaptureAddressCreateInfo; const void* pNext = {}; uint64_t opaqueCaptureAddress = {}; + }; static_assert( sizeof( BufferOpaqueCaptureAddressCreateInfo ) == sizeof( VkBufferOpaqueCaptureAddressCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BufferOpaqueCaptureAddressCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBufferOpaqueCaptureAddressCreateInfo> + { + using Type = BufferOpaqueCaptureAddressCreateInfo; + }; + struct BufferViewCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferViewCreateInfo; + VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( VULKAN_HPP_NAMESPACE::BufferViewCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Buffer buffer_ = {}, VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, @@ -26956,6 +28207,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkBufferViewCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkBufferViewCreateInfo*>( this ); @@ -26966,6 +28218,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkBufferViewCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( BufferViewCreateInfo const& ) const = default; #else @@ -26986,6 +28239,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eBufferViewCreateInfo; const void* pNext = {}; @@ -26994,12 +28249,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Format format = VULKAN_HPP_NAMESPACE::Format::eUndefined; VULKAN_HPP_NAMESPACE::DeviceSize offset = {}; VULKAN_HPP_NAMESPACE::DeviceSize range = {}; + }; static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<BufferViewCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eBufferViewCreateInfo> + { + using Type = BufferViewCreateInfo; + }; + struct CalibratedTimestampInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCalibratedTimestampInfoEXT; + VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoEXT( VULKAN_HPP_NAMESPACE::TimeDomainEXT timeDomain_ = VULKAN_HPP_NAMESPACE::TimeDomainEXT::eDevice ) VULKAN_HPP_NOEXCEPT : timeDomain( timeDomain_ ) {} @@ -27033,6 +28297,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkCalibratedTimestampInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCalibratedTimestampInfoEXT*>( this ); @@ -27043,6 +28308,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCalibratedTimestampInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( CalibratedTimestampInfoEXT const& ) const = default; #else @@ -27059,16 +28325,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCalibratedTimestampInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::TimeDomainEXT timeDomain = VULKAN_HPP_NAMESPACE::TimeDomainEXT::eDevice; + }; static_assert( sizeof( CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CalibratedTimestampInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eCalibratedTimestampInfoEXT> + { + using Type = CalibratedTimestampInfoEXT; + }; + struct CheckpointDataNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCheckpointDataNV; + VULKAN_HPP_CONSTEXPR CheckpointDataNV( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits stage_ = VULKAN_HPP_NAMESPACE::PipelineStageFlagBits::eTopOfPipe, void* pCheckpointMarker_ = {} ) VULKAN_HPP_NOEXCEPT : stage( stage_ ) @@ -27092,6 +28369,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkCheckpointDataNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCheckpointDataNV*>( this ); @@ -27102,6 +28380,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCheckpointDataNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( CheckpointDataNV const& ) const = default; #else @@ -27119,15 +28398,24 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCheckpointDataNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::PipelineStageFlagBits stage = VULKAN_HPP_NAMESPACE::PipelineStageFlagBits::eTopOfPipe; void* pCheckpointMarker = {}; + }; static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CheckpointDataNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eCheckpointDataNV> + { + using Type = CheckpointDataNV; + }; + union ClearColorValue { ClearColorValue( VULKAN_HPP_NAMESPACE::ClearColorValue const& rhs ) VULKAN_HPP_NOEXCEPT @@ -27136,19 +28424,16 @@ namespace VULKAN_HPP_NAMESPACE } ClearColorValue( const std::array<float,4>& float32_ = {} ) - { - float32 = float32_; - } + : float32( float32_ ) + {} ClearColorValue( const std::array<int32_t,4>& int32_ ) - { - int32 = int32_; - } + : int32( int32_ ) + {} ClearColorValue( const std::array<uint32_t,4>& uint32_ ) - { - uint32 = uint32_; - } + : uint32( uint32_ ) + {} ClearColorValue & setFloat32( std::array<float,4> float32_ ) VULKAN_HPP_NOEXCEPT { @@ -27191,6 +28476,7 @@ namespace VULKAN_HPP_NAMESPACE struct ClearDepthStencilValue { + VULKAN_HPP_CONSTEXPR ClearDepthStencilValue( float depth_ = {}, uint32_t stencil_ = {} ) VULKAN_HPP_NOEXCEPT : depth( depth_ ) @@ -27220,6 +28506,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkClearDepthStencilValue const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkClearDepthStencilValue*>( this ); @@ -27230,6 +28517,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkClearDepthStencilValue*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ClearDepthStencilValue const& ) const = default; #else @@ -27245,9 +28533,12 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: float depth = {}; uint32_t stencil = {}; + }; static_assert( sizeof( ClearDepthStencilValue ) == sizeof( VkClearDepthStencilValue ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ClearDepthStencilValue>::value, "struct wrapper is not a standard layout!" ); @@ -27260,22 +28551,20 @@ namespace VULKAN_HPP_NAMESPACE } ClearValue( VULKAN_HPP_NAMESPACE::ClearColorValue color_ = {} ) - { - color = color_; - } + : color( color_ ) + {} ClearValue( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue depthStencil_ ) - { - depthStencil = depthStencil_; - } + : depthStencil( depthStencil_ ) + {} - ClearValue & setColor( VULKAN_HPP_NAMESPACE::ClearColorValue color_ ) VULKAN_HPP_NOEXCEPT + ClearValue & setColor( VULKAN_HPP_NAMESPACE::ClearColorValue const & color_ ) VULKAN_HPP_NOEXCEPT { color = color_; return *this; } - ClearValue & setDepthStencil( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue depthStencil_ ) VULKAN_HPP_NOEXCEPT + ClearValue & setDepthStencil( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & depthStencil_ ) VULKAN_HPP_NOEXCEPT { depthStencil = depthStencil_; return *this; @@ -27308,6 +28597,7 @@ namespace VULKAN_HPP_NAMESPACE struct ClearAttachment { + ClearAttachment( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {}, uint32_t colorAttachment_ = {}, VULKAN_HPP_NAMESPACE::ClearValue clearValue_ = {} ) VULKAN_HPP_NOEXCEPT @@ -27339,12 +28629,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - ClearAttachment & setClearValue( VULKAN_HPP_NAMESPACE::ClearValue clearValue_ ) VULKAN_HPP_NOEXCEPT + ClearAttachment & setClearValue( VULKAN_HPP_NAMESPACE::ClearValue const & clearValue_ ) VULKAN_HPP_NOEXCEPT { clearValue = clearValue_; return *this; } + operator VkClearAttachment const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkClearAttachment*>( this ); @@ -27355,16 +28646,21 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkClearAttachment*>( this ); } + + + public: VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {}; uint32_t colorAttachment = {}; VULKAN_HPP_NAMESPACE::ClearValue clearValue = {}; + }; static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ClearAttachment>::value, "struct wrapper is not a standard layout!" ); struct ClearRect { + VULKAN_HPP_CONSTEXPR ClearRect( VULKAN_HPP_NAMESPACE::Rect2D rect_ = {}, uint32_t baseArrayLayer_ = {}, uint32_t layerCount_ = {} ) VULKAN_HPP_NOEXCEPT @@ -27384,7 +28680,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - ClearRect & setRect( VULKAN_HPP_NAMESPACE::Rect2D rect_ ) VULKAN_HPP_NOEXCEPT + ClearRect & setRect( VULKAN_HPP_NAMESPACE::Rect2D const & rect_ ) VULKAN_HPP_NOEXCEPT { rect = rect_; return *this; @@ -27402,6 +28698,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkClearRect const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkClearRect*>( this ); @@ -27412,6 +28709,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkClearRect*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ClearRect const& ) const = default; #else @@ -27428,16 +28726,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Rect2D rect = {}; uint32_t baseArrayLayer = {}; uint32_t layerCount = {}; + }; static_assert( sizeof( ClearRect ) == sizeof( VkClearRect ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ClearRect>::value, "struct wrapper is not a standard layout!" ); struct CoarseSampleLocationNV { + VULKAN_HPP_CONSTEXPR CoarseSampleLocationNV( uint32_t pixelX_ = {}, uint32_t pixelY_ = {}, uint32_t sample_ = {} ) VULKAN_HPP_NOEXCEPT @@ -27475,6 +28777,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkCoarseSampleLocationNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCoarseSampleLocationNV*>( this ); @@ -27485,6 +28788,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCoarseSampleLocationNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( CoarseSampleLocationNV const& ) const = default; #else @@ -27501,16 +28805,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t pixelX = {}; uint32_t pixelY = {}; uint32_t sample = {}; + }; static_assert( sizeof( CoarseSampleLocationNV ) == sizeof( VkCoarseSampleLocationNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CoarseSampleLocationNV>::value, "struct wrapper is not a standard layout!" ); struct CoarseSampleOrderCustomNV { + VULKAN_HPP_CONSTEXPR CoarseSampleOrderCustomNV( VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV shadingRate_ = VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV::eNoInvocations, uint32_t sampleCount_ = {}, uint32_t sampleLocationCount_ = {}, @@ -27556,6 +28864,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkCoarseSampleOrderCustomNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( this ); @@ -27566,6 +28875,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCoarseSampleOrderCustomNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( CoarseSampleOrderCustomNV const& ) const = default; #else @@ -27583,17 +28893,22 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV shadingRate = VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV::eNoInvocations; uint32_t sampleCount = {}; uint32_t sampleLocationCount = {}; const VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV* pSampleLocations = {}; + }; static_assert( sizeof( CoarseSampleOrderCustomNV ) == sizeof( VkCoarseSampleOrderCustomNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CoarseSampleOrderCustomNV>::value, "struct wrapper is not a standard layout!" ); struct CommandBufferAllocateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferAllocateInfo; + VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( VULKAN_HPP_NAMESPACE::CommandPool commandPool_ = {}, VULKAN_HPP_NAMESPACE::CommandBufferLevel level_ = VULKAN_HPP_NAMESPACE::CommandBufferLevel::ePrimary, uint32_t commandBufferCount_ = {} ) VULKAN_HPP_NOEXCEPT @@ -27643,6 +28958,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkCommandBufferAllocateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCommandBufferAllocateInfo*>( this ); @@ -27653,6 +28969,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCommandBufferAllocateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( CommandBufferAllocateInfo const& ) const = default; #else @@ -27671,18 +28988,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCommandBufferAllocateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::CommandPool commandPool = {}; VULKAN_HPP_NAMESPACE::CommandBufferLevel level = VULKAN_HPP_NAMESPACE::CommandBufferLevel::ePrimary; uint32_t commandBufferCount = {}; + }; static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CommandBufferAllocateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eCommandBufferAllocateInfo> + { + using Type = CommandBufferAllocateInfo; + }; + struct CommandBufferInheritanceInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceInfo; + VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( VULKAN_HPP_NAMESPACE::RenderPass renderPass_ = {}, uint32_t subpass_ = {}, VULKAN_HPP_NAMESPACE::Framebuffer framebuffer_ = {}, @@ -27756,6 +29084,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkCommandBufferInheritanceInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCommandBufferInheritanceInfo*>( this ); @@ -27766,6 +29095,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCommandBufferInheritanceInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( CommandBufferInheritanceInfo const& ) const = default; #else @@ -27787,6 +29117,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCommandBufferInheritanceInfo; const void* pNext = {}; @@ -27796,12 +29128,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 occlusionQueryEnable = {}; VULKAN_HPP_NAMESPACE::QueryControlFlags queryFlags = {}; VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags pipelineStatistics = {}; + }; static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CommandBufferInheritanceInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eCommandBufferInheritanceInfo> + { + using Type = CommandBufferInheritanceInfo; + }; + struct CommandBufferBeginInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferBeginInfo; + VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags flags_ = {}, const VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo* pInheritanceInfo_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -27843,6 +29184,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkCommandBufferBeginInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCommandBufferBeginInfo*>( this ); @@ -27853,6 +29195,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCommandBufferBeginInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( CommandBufferBeginInfo const& ) const = default; #else @@ -27870,17 +29213,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCommandBufferBeginInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags flags = {}; const VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo* pInheritanceInfo = {}; + }; static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CommandBufferBeginInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eCommandBufferBeginInfo> + { + using Type = CommandBufferBeginInfo; + }; + struct CommandBufferInheritanceConditionalRenderingInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT; + VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 conditionalRenderingEnable_ = {} ) VULKAN_HPP_NOEXCEPT : conditionalRenderingEnable( conditionalRenderingEnable_ ) {} @@ -27914,6 +29268,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>( this ); @@ -27924,6 +29279,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( CommandBufferInheritanceConditionalRenderingInfoEXT const& ) const = default; #else @@ -27940,16 +29296,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 conditionalRenderingEnable = {}; + }; static_assert( sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) == sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CommandBufferInheritanceConditionalRenderingInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT> + { + using Type = CommandBufferInheritanceConditionalRenderingInfoEXT; + }; + struct CommandBufferInheritanceRenderPassTransformInfoQCOM { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM; + VULKAN_HPP_CONSTEXPR CommandBufferInheritanceRenderPassTransformInfoQCOM( VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR transform_ = VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR::eIdentity, VULKAN_HPP_NAMESPACE::Rect2D renderArea_ = {} ) VULKAN_HPP_NOEXCEPT : transform( transform_ ) @@ -27985,12 +29352,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - CommandBufferInheritanceRenderPassTransformInfoQCOM & setRenderArea( VULKAN_HPP_NAMESPACE::Rect2D renderArea_ ) VULKAN_HPP_NOEXCEPT + CommandBufferInheritanceRenderPassTransformInfoQCOM & setRenderArea( VULKAN_HPP_NAMESPACE::Rect2D const & renderArea_ ) VULKAN_HPP_NOEXCEPT { renderArea = renderArea_; return *this; } + operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>( this ); @@ -28001,6 +29369,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( CommandBufferInheritanceRenderPassTransformInfoQCOM const& ) const = default; #else @@ -28018,17 +29387,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM; void* pNext = {}; VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR transform = VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR::eIdentity; VULKAN_HPP_NAMESPACE::Rect2D renderArea = {}; + }; static_assert( sizeof( CommandBufferInheritanceRenderPassTransformInfoQCOM ) == sizeof( VkCommandBufferInheritanceRenderPassTransformInfoQCOM ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CommandBufferInheritanceRenderPassTransformInfoQCOM>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM> + { + using Type = CommandBufferInheritanceRenderPassTransformInfoQCOM; + }; + struct CommandPoolCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandPoolCreateInfo; + VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags flags_ = {}, uint32_t queueFamilyIndex_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -28070,6 +29450,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkCommandPoolCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCommandPoolCreateInfo*>( this ); @@ -28080,6 +29461,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCommandPoolCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( CommandPoolCreateInfo const& ) const = default; #else @@ -28097,17 +29479,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCommandPoolCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags flags = {}; uint32_t queueFamilyIndex = {}; + }; static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CommandPoolCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eCommandPoolCreateInfo> + { + using Type = CommandPoolCreateInfo; + }; + struct SpecializationMapEntry { + VULKAN_HPP_CONSTEXPR SpecializationMapEntry( uint32_t constantID_ = {}, uint32_t offset_ = {}, size_t size_ = {} ) VULKAN_HPP_NOEXCEPT @@ -28145,6 +29537,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSpecializationMapEntry const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSpecializationMapEntry*>( this ); @@ -28155,6 +29548,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSpecializationMapEntry*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SpecializationMapEntry const& ) const = default; #else @@ -28171,16 +29565,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t constantID = {}; uint32_t offset = {}; size_t size = {}; + }; static_assert( sizeof( SpecializationMapEntry ) == sizeof( VkSpecializationMapEntry ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SpecializationMapEntry>::value, "struct wrapper is not a standard layout!" ); struct SpecializationInfo { + VULKAN_HPP_CONSTEXPR SpecializationInfo( uint32_t mapEntryCount_ = {}, const VULKAN_HPP_NAMESPACE::SpecializationMapEntry* pMapEntries_ = {}, size_t dataSize_ = {}, @@ -28226,6 +29624,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSpecializationInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSpecializationInfo*>( this ); @@ -28236,6 +29635,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSpecializationInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SpecializationInfo const& ) const = default; #else @@ -28253,17 +29653,22 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t mapEntryCount = {}; const VULKAN_HPP_NAMESPACE::SpecializationMapEntry* pMapEntries = {}; size_t dataSize = {}; const void* pData = {}; + }; static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SpecializationInfo>::value, "struct wrapper is not a standard layout!" ); struct PipelineShaderStageCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineShaderStageCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::ShaderStageFlagBits stage_ = VULKAN_HPP_NAMESPACE::ShaderStageFlagBits::eVertex, VULKAN_HPP_NAMESPACE::ShaderModule module_ = {}, @@ -28329,6 +29734,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineShaderStageCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineShaderStageCreateInfo*>( this ); @@ -28339,6 +29745,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineShaderStageCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineShaderStageCreateInfo const& ) const = default; #else @@ -28359,6 +29766,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineShaderStageCreateInfo; const void* pNext = {}; @@ -28367,12 +29776,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ShaderModule module = {}; const char* pName = {}; const VULKAN_HPP_NAMESPACE::SpecializationInfo* pSpecializationInfo = {}; + }; static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineShaderStageCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineShaderStageCreateInfo> + { + using Type = PipelineShaderStageCreateInfo; + }; + struct ComputePipelineCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eComputePipelineCreateInfo; + VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo stage_ = {}, VULKAN_HPP_NAMESPACE::PipelineLayout layout_ = {}, @@ -28414,7 +29832,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - ComputePipelineCreateInfo & setStage( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo stage_ ) VULKAN_HPP_NOEXCEPT + ComputePipelineCreateInfo & setStage( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & stage_ ) VULKAN_HPP_NOEXCEPT { stage = stage_; return *this; @@ -28438,6 +29856,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkComputePipelineCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkComputePipelineCreateInfo*>( this ); @@ -28448,6 +29867,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkComputePipelineCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ComputePipelineCreateInfo const& ) const = default; #else @@ -28468,6 +29888,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eComputePipelineCreateInfo; const void* pNext = {}; @@ -28476,12 +29898,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PipelineLayout layout = {}; VULKAN_HPP_NAMESPACE::Pipeline basePipelineHandle = {}; int32_t basePipelineIndex = {}; + }; static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ComputePipelineCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eComputePipelineCreateInfo> + { + using Type = ComputePipelineCreateInfo; + }; + struct ConditionalRenderingBeginInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eConditionalRenderingBeginInfoEXT; + VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {}, VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagsEXT flags_ = {} ) VULKAN_HPP_NOEXCEPT @@ -28531,6 +29962,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkConditionalRenderingBeginInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>( this ); @@ -28541,6 +29973,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ConditionalRenderingBeginInfoEXT const& ) const = default; #else @@ -28559,18 +29992,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Buffer buffer = {}; VULKAN_HPP_NAMESPACE::DeviceSize offset = {}; VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagsEXT flags = {}; + }; static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ConditionalRenderingBeginInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eConditionalRenderingBeginInfoEXT> + { + using Type = ConditionalRenderingBeginInfoEXT; + }; + struct ConformanceVersion { + VULKAN_HPP_CONSTEXPR ConformanceVersion( uint8_t major_ = {}, uint8_t minor_ = {}, uint8_t subminor_ = {}, @@ -28616,6 +30059,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkConformanceVersion const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkConformanceVersion*>( this ); @@ -28626,6 +30070,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkConformanceVersion*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ConformanceVersion const& ) const = default; #else @@ -28643,17 +30088,22 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint8_t major = {}; uint8_t minor = {}; uint8_t subminor = {}; uint8_t patch = {}; + }; static_assert( sizeof( ConformanceVersion ) == sizeof( VkConformanceVersion ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ConformanceVersion>::value, "struct wrapper is not a standard layout!" ); struct CooperativeMatrixPropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCooperativeMatrixPropertiesNV; + VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( uint32_t MSize_ = {}, uint32_t NSize_ = {}, uint32_t KSize_ = {}, @@ -28743,6 +30193,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkCooperativeMatrixPropertiesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCooperativeMatrixPropertiesNV*>( this ); @@ -28753,6 +30204,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCooperativeMatrixPropertiesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( CooperativeMatrixPropertiesNV const& ) const = default; #else @@ -28776,6 +30228,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCooperativeMatrixPropertiesNV; void* pNext = {}; @@ -28787,13 +30241,22 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ComponentTypeNV CType = VULKAN_HPP_NAMESPACE::ComponentTypeNV::eFloat16; VULKAN_HPP_NAMESPACE::ComponentTypeNV DType = VULKAN_HPP_NAMESPACE::ComponentTypeNV::eFloat16; VULKAN_HPP_NAMESPACE::ScopeNV scope = VULKAN_HPP_NAMESPACE::ScopeNV::eDevice; + }; static_assert( sizeof( CooperativeMatrixPropertiesNV ) == sizeof( VkCooperativeMatrixPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CooperativeMatrixPropertiesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eCooperativeMatrixPropertiesNV> + { + using Type = CooperativeMatrixPropertiesNV; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct CopyAccelerationStructureInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyAccelerationStructureInfoKHR; + VULKAN_HPP_CONSTEXPR CopyAccelerationStructureInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR src_ = {}, VULKAN_HPP_NAMESPACE::AccelerationStructureKHR dst_ = {}, VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode_ = VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR::eClone ) VULKAN_HPP_NOEXCEPT @@ -28843,6 +30306,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkCopyAccelerationStructureInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCopyAccelerationStructureInfoKHR*>( this ); @@ -28853,6 +30317,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCopyAccelerationStructureInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( CopyAccelerationStructureInfoKHR const& ) const = default; #else @@ -28871,20 +30336,31 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyAccelerationStructureInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::AccelerationStructureKHR src = {}; VULKAN_HPP_NAMESPACE::AccelerationStructureKHR dst = {}; VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode = VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR::eClone; + }; static_assert( sizeof( CopyAccelerationStructureInfoKHR ) == sizeof( VkCopyAccelerationStructureInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CopyAccelerationStructureInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eCopyAccelerationStructureInfoKHR> + { + using Type = CopyAccelerationStructureInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct CopyAccelerationStructureToMemoryInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR; + CopyAccelerationStructureToMemoryInfoKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR src_ = {}, VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR dst_ = {}, VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode_ = VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR::eClone ) VULKAN_HPP_NOEXCEPT @@ -28922,7 +30398,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - CopyAccelerationStructureToMemoryInfoKHR & setDst( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR dst_ ) VULKAN_HPP_NOEXCEPT + CopyAccelerationStructureToMemoryInfoKHR & setDst( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR const & dst_ ) VULKAN_HPP_NOEXCEPT { dst = dst_; return *this; @@ -28934,6 +30410,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkCopyAccelerationStructureToMemoryInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR*>( this ); @@ -28944,19 +30421,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR*>( this ); } + + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::AccelerationStructureKHR src = {}; VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR dst = {}; VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode = VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR::eClone; + }; static_assert( sizeof( CopyAccelerationStructureToMemoryInfoKHR ) == sizeof( VkCopyAccelerationStructureToMemoryInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CopyAccelerationStructureToMemoryInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eCopyAccelerationStructureToMemoryInfoKHR> + { + using Type = CopyAccelerationStructureToMemoryInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct CopyDescriptorSet { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyDescriptorSet; + VULKAN_HPP_CONSTEXPR CopyDescriptorSet( VULKAN_HPP_NAMESPACE::DescriptorSet srcSet_ = {}, uint32_t srcBinding_ = {}, uint32_t srcArrayElement_ = {}, @@ -29038,6 +30527,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkCopyDescriptorSet const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCopyDescriptorSet*>( this ); @@ -29048,6 +30538,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCopyDescriptorSet*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( CopyDescriptorSet const& ) const = default; #else @@ -29070,6 +30561,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyDescriptorSet; const void* pNext = {}; @@ -29080,13 +30573,22 @@ namespace VULKAN_HPP_NAMESPACE uint32_t dstBinding = {}; uint32_t dstArrayElement = {}; uint32_t descriptorCount = {}; + }; static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CopyDescriptorSet>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eCopyDescriptorSet> + { + using Type = CopyDescriptorSet; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct CopyMemoryToAccelerationStructureInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR; + CopyMemoryToAccelerationStructureInfoKHR( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR src_ = {}, VULKAN_HPP_NAMESPACE::AccelerationStructureKHR dst_ = {}, VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode_ = VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR::eClone ) VULKAN_HPP_NOEXCEPT @@ -29118,7 +30620,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - CopyMemoryToAccelerationStructureInfoKHR & setSrc( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR src_ ) VULKAN_HPP_NOEXCEPT + CopyMemoryToAccelerationStructureInfoKHR & setSrc( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const & src_ ) VULKAN_HPP_NOEXCEPT { src = src_; return *this; @@ -29136,6 +30638,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkCopyMemoryToAccelerationStructureInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR*>( this ); @@ -29146,20 +30649,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR*>( this ); } + + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR src = {}; VULKAN_HPP_NAMESPACE::AccelerationStructureKHR dst = {}; VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode = VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR::eClone; + }; static_assert( sizeof( CopyMemoryToAccelerationStructureInfoKHR ) == sizeof( VkCopyMemoryToAccelerationStructureInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<CopyMemoryToAccelerationStructureInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eCopyMemoryToAccelerationStructureInfoKHR> + { + using Type = CopyMemoryToAccelerationStructureInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_USE_PLATFORM_WIN32_KHR struct D3D12FenceSubmitInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eD3D12FenceSubmitInfoKHR; + VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = {}, const uint64_t* pWaitSemaphoreValues_ = {}, uint32_t signalSemaphoreValuesCount_ = {}, @@ -29217,6 +30732,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkD3D12FenceSubmitInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>( this ); @@ -29227,6 +30743,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( D3D12FenceSubmitInfoKHR const& ) const = default; #else @@ -29246,6 +30763,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR; const void* pNext = {}; @@ -29253,13 +30772,22 @@ namespace VULKAN_HPP_NAMESPACE const uint64_t* pWaitSemaphoreValues = {}; uint32_t signalSemaphoreValuesCount = {}; const uint64_t* pSignalSemaphoreValues = {}; + }; static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<D3D12FenceSubmitInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eD3D12FenceSubmitInfoKHR> + { + using Type = D3D12FenceSubmitInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct DebugMarkerMarkerInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerMarkerInfoEXT; + VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = {}, std::array<float,4> const& color_ = {} ) VULKAN_HPP_NOEXCEPT : pMarkerName( pMarkerName_ ) @@ -29301,6 +30829,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDebugMarkerMarkerInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( this ); @@ -29311,6 +30840,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DebugMarkerMarkerInfoEXT const& ) const = default; #else @@ -29328,17 +30858,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT; const void* pNext = {}; const char* pMarkerName = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> color = {}; + }; static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DebugMarkerMarkerInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDebugMarkerMarkerInfoEXT> + { + using Type = DebugMarkerMarkerInfoEXT; + }; + struct DebugMarkerObjectNameInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerObjectNameInfoEXT; + VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_ = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = {}, const char* pObjectName_ = {} ) VULKAN_HPP_NOEXCEPT @@ -29388,6 +30929,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDebugMarkerObjectNameInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( this ); @@ -29398,6 +30940,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DebugMarkerObjectNameInfoEXT const& ) const = default; #else @@ -29416,18 +30959,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; uint64_t object = {}; const char* pObjectName = {}; + }; static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DebugMarkerObjectNameInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDebugMarkerObjectNameInfoEXT> + { + using Type = DebugMarkerObjectNameInfoEXT; + }; + struct DebugMarkerObjectTagInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerObjectTagInfoEXT; + VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_ = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = {}, uint64_t tagName_ = {}, @@ -29493,6 +31047,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDebugMarkerObjectTagInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( this ); @@ -29503,6 +31058,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DebugMarkerObjectTagInfoEXT const& ) const = default; #else @@ -29523,6 +31079,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT; const void* pNext = {}; @@ -29531,12 +31089,21 @@ namespace VULKAN_HPP_NAMESPACE uint64_t tagName = {}; size_t tagSize = {}; const void* pTag = {}; + }; static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DebugMarkerObjectTagInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDebugMarkerObjectTagInfoEXT> + { + using Type = DebugMarkerObjectTagInfoEXT; + }; + struct DebugReportCallbackCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugReportCallbackCreateInfoEXT; + VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags_ = {}, PFN_vkDebugReportCallbackEXT pfnCallback_ = {}, void* pUserData_ = {} ) VULKAN_HPP_NOEXCEPT @@ -29586,6 +31153,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDebugReportCallbackCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( this ); @@ -29596,6 +31164,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DebugReportCallbackCreateInfoEXT const& ) const = default; #else @@ -29614,18 +31183,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags = {}; PFN_vkDebugReportCallbackEXT pfnCallback = {}; void* pUserData = {}; + }; static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DebugReportCallbackCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDebugReportCallbackCreateInfoEXT> + { + using Type = DebugReportCallbackCreateInfoEXT; + }; + struct DebugUtilsLabelEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsLabelEXT; + VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( const char* pLabelName_ = {}, std::array<float,4> const& color_ = {} ) VULKAN_HPP_NOEXCEPT : pLabelName( pLabelName_ ) @@ -29667,6 +31247,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDebugUtilsLabelEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDebugUtilsLabelEXT*>( this ); @@ -29677,6 +31258,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDebugUtilsLabelEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DebugUtilsLabelEXT const& ) const = default; #else @@ -29694,17 +31276,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsLabelEXT; const void* pNext = {}; const char* pLabelName = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> color = {}; + }; static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DebugUtilsLabelEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDebugUtilsLabelEXT> + { + using Type = DebugUtilsLabelEXT; + }; + struct DebugUtilsObjectNameInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsObjectNameInfoEXT; + VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_ = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown, uint64_t objectHandle_ = {}, const char* pObjectName_ = {} ) VULKAN_HPP_NOEXCEPT @@ -29754,6 +31347,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDebugUtilsObjectNameInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>( this ); @@ -29764,6 +31358,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DebugUtilsObjectNameInfoEXT const& ) const = default; #else @@ -29782,18 +31377,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown; uint64_t objectHandle = {}; const char* pObjectName = {}; + }; static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DebugUtilsObjectNameInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDebugUtilsObjectNameInfoEXT> + { + using Type = DebugUtilsObjectNameInfoEXT; + }; + struct DebugUtilsMessengerCallbackDataEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsMessengerCallbackDataEXT; + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagsEXT flags_ = {}, const char* pMessageIdName_ = {}, int32_t messageIdNumber_ = {}, @@ -29899,6 +31505,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDebugUtilsMessengerCallbackDataEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>( this ); @@ -29909,6 +31516,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DebugUtilsMessengerCallbackDataEXT const& ) const = default; #else @@ -29934,6 +31542,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT; const void* pNext = {}; @@ -29947,12 +31557,21 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT* pCmdBufLabels = {}; uint32_t objectCount = {}; const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT* pObjects = {}; + }; static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DebugUtilsMessengerCallbackDataEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDebugUtilsMessengerCallbackDataEXT> + { + using Type = DebugUtilsMessengerCallbackDataEXT; + }; + struct DebugUtilsMessengerCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsMessengerCreateInfoEXT; + VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT flags_ = {}, VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = {}, VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType_ = {}, @@ -30018,6 +31637,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDebugUtilsMessengerCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( this ); @@ -30028,6 +31648,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DebugUtilsMessengerCreateInfoEXT const& ) const = default; #else @@ -30048,6 +31669,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT; const void* pNext = {}; @@ -30056,12 +31679,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType = {}; PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback = {}; void* pUserData = {}; + }; static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DebugUtilsMessengerCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDebugUtilsMessengerCreateInfoEXT> + { + using Type = DebugUtilsMessengerCreateInfoEXT; + }; + struct DebugUtilsObjectTagInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsObjectTagInfoEXT; + VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_ = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown, uint64_t objectHandle_ = {}, uint64_t tagName_ = {}, @@ -30127,6 +31759,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDebugUtilsObjectTagInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>( this ); @@ -30137,6 +31770,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DebugUtilsObjectTagInfoEXT const& ) const = default; #else @@ -30157,6 +31791,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT; const void* pNext = {}; @@ -30165,12 +31801,21 @@ namespace VULKAN_HPP_NAMESPACE uint64_t tagName = {}; size_t tagSize = {}; const void* pTag = {}; + }; static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DebugUtilsObjectTagInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDebugUtilsObjectTagInfoEXT> + { + using Type = DebugUtilsObjectTagInfoEXT; + }; + struct DedicatedAllocationBufferCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDedicatedAllocationBufferCreateInfoNV; + VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocation_ = {} ) VULKAN_HPP_NOEXCEPT : dedicatedAllocation( dedicatedAllocation_ ) {} @@ -30204,6 +31849,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDedicatedAllocationBufferCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>( this ); @@ -30214,6 +31860,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DedicatedAllocationBufferCreateInfoNV const& ) const = default; #else @@ -30230,16 +31877,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocation = {}; + }; static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DedicatedAllocationBufferCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDedicatedAllocationBufferCreateInfoNV> + { + using Type = DedicatedAllocationBufferCreateInfoNV; + }; + struct DedicatedAllocationImageCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDedicatedAllocationImageCreateInfoNV; + VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocation_ = {} ) VULKAN_HPP_NOEXCEPT : dedicatedAllocation( dedicatedAllocation_ ) {} @@ -30273,6 +31931,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDedicatedAllocationImageCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>( this ); @@ -30283,6 +31942,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DedicatedAllocationImageCreateInfoNV const& ) const = default; #else @@ -30299,16 +31959,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocation = {}; + }; static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DedicatedAllocationImageCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDedicatedAllocationImageCreateInfoNV> + { + using Type = DedicatedAllocationImageCreateInfoNV; + }; + struct DedicatedAllocationMemoryAllocateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV; + VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( VULKAN_HPP_NAMESPACE::Image image_ = {}, VULKAN_HPP_NAMESPACE::Buffer buffer_ = {} ) VULKAN_HPP_NOEXCEPT : image( image_ ) @@ -30350,6 +32021,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDedicatedAllocationMemoryAllocateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>( this ); @@ -30360,6 +32032,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DedicatedAllocationMemoryAllocateInfoNV const& ) const = default; #else @@ -30377,18 +32050,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Image image = {}; VULKAN_HPP_NAMESPACE::Buffer buffer = {}; + }; static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DedicatedAllocationMemoryAllocateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDedicatedAllocationMemoryAllocateInfoNV> + { + using Type = DedicatedAllocationMemoryAllocateInfoNV; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct DeferredOperationInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeferredOperationInfoKHR; + VULKAN_HPP_CONSTEXPR DeferredOperationInfoKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operationHandle_ = {} ) VULKAN_HPP_NOEXCEPT : operationHandle( operationHandle_ ) {} @@ -30422,6 +32106,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeferredOperationInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeferredOperationInfoKHR*>( this ); @@ -30432,6 +32117,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeferredOperationInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeferredOperationInfoKHR const& ) const = default; #else @@ -30448,17 +32134,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeferredOperationInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeferredOperationKHR operationHandle = {}; + }; static_assert( sizeof( DeferredOperationInfoKHR ) == sizeof( VkDeferredOperationInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeferredOperationInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eDeferredOperationInfoKHR> + { + using Type = DeferredOperationInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct DescriptorBufferInfo { + VULKAN_HPP_CONSTEXPR DescriptorBufferInfo( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize range_ = {} ) VULKAN_HPP_NOEXCEPT @@ -30496,6 +32192,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDescriptorBufferInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDescriptorBufferInfo*>( this ); @@ -30506,6 +32203,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDescriptorBufferInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DescriptorBufferInfo const& ) const = default; #else @@ -30522,16 +32220,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Buffer buffer = {}; VULKAN_HPP_NAMESPACE::DeviceSize offset = {}; VULKAN_HPP_NAMESPACE::DeviceSize range = {}; + }; static_assert( sizeof( DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DescriptorBufferInfo>::value, "struct wrapper is not a standard layout!" ); struct DescriptorImageInfo { + VULKAN_HPP_CONSTEXPR DescriptorImageInfo( VULKAN_HPP_NAMESPACE::Sampler sampler_ = {}, VULKAN_HPP_NAMESPACE::ImageView imageView_ = {}, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT @@ -30569,6 +32271,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDescriptorImageInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDescriptorImageInfo*>( this ); @@ -30579,6 +32282,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDescriptorImageInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DescriptorImageInfo const& ) const = default; #else @@ -30595,16 +32299,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Sampler sampler = {}; VULKAN_HPP_NAMESPACE::ImageView imageView = {}; VULKAN_HPP_NAMESPACE::ImageLayout imageLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined; + }; static_assert( sizeof( DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DescriptorImageInfo>::value, "struct wrapper is not a standard layout!" ); struct DescriptorPoolSize { + VULKAN_HPP_CONSTEXPR DescriptorPoolSize( VULKAN_HPP_NAMESPACE::DescriptorType type_ = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler, uint32_t descriptorCount_ = {} ) VULKAN_HPP_NOEXCEPT : type( type_ ) @@ -30634,6 +32342,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDescriptorPoolSize const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDescriptorPoolSize*>( this ); @@ -30644,6 +32353,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDescriptorPoolSize*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DescriptorPoolSize const& ) const = default; #else @@ -30659,15 +32369,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::DescriptorType type = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler; uint32_t descriptorCount = {}; + }; static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DescriptorPoolSize>::value, "struct wrapper is not a standard layout!" ); struct DescriptorPoolCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorPoolCreateInfo; + VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags flags_ = {}, uint32_t maxSets_ = {}, uint32_t poolSizeCount_ = {}, @@ -30725,6 +32440,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDescriptorPoolCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDescriptorPoolCreateInfo*>( this ); @@ -30735,6 +32451,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDescriptorPoolCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DescriptorPoolCreateInfo const& ) const = default; #else @@ -30754,6 +32471,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorPoolCreateInfo; const void* pNext = {}; @@ -30761,12 +32480,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t maxSets = {}; uint32_t poolSizeCount = {}; const VULKAN_HPP_NAMESPACE::DescriptorPoolSize* pPoolSizes = {}; + }; static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DescriptorPoolCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDescriptorPoolCreateInfo> + { + using Type = DescriptorPoolCreateInfo; + }; + struct DescriptorPoolInlineUniformBlockCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT; + VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = {} ) VULKAN_HPP_NOEXCEPT : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ ) {} @@ -30800,6 +32528,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDescriptorPoolInlineUniformBlockCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>( this ); @@ -30810,6 +32539,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DescriptorPoolInlineUniformBlockCreateInfoEXT const& ) const = default; #else @@ -30826,16 +32556,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT; const void* pNext = {}; uint32_t maxInlineUniformBlockBindings = {}; + }; static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DescriptorPoolInlineUniformBlockCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT> + { + using Type = DescriptorPoolInlineUniformBlockCreateInfoEXT; + }; + struct DescriptorSetAllocateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetAllocateInfo; + VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool_ = {}, uint32_t descriptorSetCount_ = {}, const VULKAN_HPP_NAMESPACE::DescriptorSetLayout* pSetLayouts_ = {} ) VULKAN_HPP_NOEXCEPT @@ -30885,6 +32626,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDescriptorSetAllocateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDescriptorSetAllocateInfo*>( this ); @@ -30895,6 +32637,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDescriptorSetAllocateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DescriptorSetAllocateInfo const& ) const = default; #else @@ -30913,18 +32656,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetAllocateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool = {}; uint32_t descriptorSetCount = {}; const VULKAN_HPP_NAMESPACE::DescriptorSetLayout* pSetLayouts = {}; + }; static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DescriptorSetAllocateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDescriptorSetAllocateInfo> + { + using Type = DescriptorSetAllocateInfo; + }; + struct DescriptorSetLayoutBinding { + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBinding( uint32_t binding_ = {}, VULKAN_HPP_NAMESPACE::DescriptorType descriptorType_ = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler, uint32_t descriptorCount_ = {}, @@ -30978,6 +32731,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDescriptorSetLayoutBinding const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDescriptorSetLayoutBinding*>( this ); @@ -30988,6 +32742,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDescriptorSetLayoutBinding*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DescriptorSetLayoutBinding const& ) const = default; #else @@ -31006,18 +32761,23 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t binding = {}; VULKAN_HPP_NAMESPACE::DescriptorType descriptorType = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler; uint32_t descriptorCount = {}; VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags = {}; const VULKAN_HPP_NAMESPACE::Sampler* pImmutableSamplers = {}; + }; static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DescriptorSetLayoutBinding>::value, "struct wrapper is not a standard layout!" ); struct DescriptorSetLayoutBindingFlagsCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo; + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfo( uint32_t bindingCount_ = {}, const VULKAN_HPP_NAMESPACE::DescriptorBindingFlags* pBindingFlags_ = {} ) VULKAN_HPP_NOEXCEPT : bindingCount( bindingCount_ ) @@ -31059,6 +32819,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDescriptorSetLayoutBindingFlagsCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>( this ); @@ -31069,6 +32830,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DescriptorSetLayoutBindingFlagsCreateInfo const& ) const = default; #else @@ -31086,17 +32848,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo; const void* pNext = {}; uint32_t bindingCount = {}; const VULKAN_HPP_NAMESPACE::DescriptorBindingFlags* pBindingFlags = {}; + }; static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfo ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DescriptorSetLayoutBindingFlagsCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo> + { + using Type = DescriptorSetLayoutBindingFlagsCreateInfo; + }; + struct DescriptorSetLayoutCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutCreateInfo; + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags flags_ = {}, uint32_t bindingCount_ = {}, const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding* pBindings_ = {} ) VULKAN_HPP_NOEXCEPT @@ -31146,6 +32919,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDescriptorSetLayoutCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( this ); @@ -31156,6 +32930,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DescriptorSetLayoutCreateInfo const& ) const = default; #else @@ -31174,18 +32949,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags flags = {}; uint32_t bindingCount = {}; const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding* pBindings = {}; + }; static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DescriptorSetLayoutCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDescriptorSetLayoutCreateInfo> + { + using Type = DescriptorSetLayoutCreateInfo; + }; + struct DescriptorSetLayoutSupport { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutSupport; + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutSupport( VULKAN_HPP_NAMESPACE::Bool32 supported_ = {} ) VULKAN_HPP_NOEXCEPT : supported( supported_ ) {} @@ -31207,6 +32993,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDescriptorSetLayoutSupport const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDescriptorSetLayoutSupport*>( this ); @@ -31217,6 +33004,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDescriptorSetLayoutSupport*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DescriptorSetLayoutSupport const& ) const = default; #else @@ -31233,16 +33021,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetLayoutSupport; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 supported = {}; + }; static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DescriptorSetLayoutSupport>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDescriptorSetLayoutSupport> + { + using Type = DescriptorSetLayoutSupport; + }; + struct DescriptorSetVariableDescriptorCountAllocateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo; + VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfo( uint32_t descriptorSetCount_ = {}, const uint32_t* pDescriptorCounts_ = {} ) VULKAN_HPP_NOEXCEPT : descriptorSetCount( descriptorSetCount_ ) @@ -31284,6 +33083,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDescriptorSetVariableDescriptorCountAllocateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>( this ); @@ -31294,6 +33094,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DescriptorSetVariableDescriptorCountAllocateInfo const& ) const = default; #else @@ -31311,17 +33112,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo; const void* pNext = {}; uint32_t descriptorSetCount = {}; const uint32_t* pDescriptorCounts = {}; + }; static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfo ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DescriptorSetVariableDescriptorCountAllocateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo> + { + using Type = DescriptorSetVariableDescriptorCountAllocateInfo; + }; + struct DescriptorSetVariableDescriptorCountLayoutSupport { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport; + VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountLayoutSupport( uint32_t maxVariableDescriptorCount_ = {} ) VULKAN_HPP_NOEXCEPT : maxVariableDescriptorCount( maxVariableDescriptorCount_ ) {} @@ -31343,6 +33155,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDescriptorSetVariableDescriptorCountLayoutSupport const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>( this ); @@ -31353,6 +33166,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DescriptorSetVariableDescriptorCountLayoutSupport const& ) const = default; #else @@ -31369,16 +33183,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport; void* pNext = {}; uint32_t maxVariableDescriptorCount = {}; + }; static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupport ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupport ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DescriptorSetVariableDescriptorCountLayoutSupport>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport> + { + using Type = DescriptorSetVariableDescriptorCountLayoutSupport; + }; + struct DescriptorUpdateTemplateEntry { + VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateEntry( uint32_t dstBinding_ = {}, uint32_t dstArrayElement_ = {}, uint32_t descriptorCount_ = {}, @@ -31440,6 +33264,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDescriptorUpdateTemplateEntry const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDescriptorUpdateTemplateEntry*>( this ); @@ -31450,6 +33275,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DescriptorUpdateTemplateEntry const& ) const = default; #else @@ -31469,6 +33295,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t dstBinding = {}; uint32_t dstArrayElement = {}; @@ -31476,12 +33304,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DescriptorType descriptorType = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler; size_t offset = {}; size_t stride = {}; + }; static_assert( sizeof( DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DescriptorUpdateTemplateEntry>::value, "struct wrapper is not a standard layout!" ); struct DescriptorUpdateTemplateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorUpdateTemplateCreateInfo; + VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags flags_ = {}, uint32_t descriptorUpdateEntryCount_ = {}, const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = {}, @@ -31571,6 +33402,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDescriptorUpdateTemplateCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( this ); @@ -31581,6 +33413,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DescriptorUpdateTemplateCreateInfo const& ) const = default; #else @@ -31604,6 +33437,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo; const void* pNext = {}; @@ -31615,12 +33450,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics; VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout = {}; uint32_t set = {}; + }; static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DescriptorUpdateTemplateCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDescriptorUpdateTemplateCreateInfo> + { + using Type = DescriptorUpdateTemplateCreateInfo; + }; + struct DeviceQueueCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueCreateInfo; + VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags flags_ = {}, uint32_t queueFamilyIndex_ = {}, uint32_t queueCount_ = {}, @@ -31678,6 +33522,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceQueueCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceQueueCreateInfo*>( this ); @@ -31688,6 +33533,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceQueueCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceQueueCreateInfo const& ) const = default; #else @@ -31707,6 +33553,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceQueueCreateInfo; const void* pNext = {}; @@ -31714,12 +33562,20 @@ namespace VULKAN_HPP_NAMESPACE uint32_t queueFamilyIndex = {}; uint32_t queueCount = {}; const float* pQueuePriorities = {}; + }; static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceQueueCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceQueueCreateInfo> + { + using Type = DeviceQueueCreateInfo; + }; + struct PhysicalDeviceFeatures { + VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess_ = {}, VULKAN_HPP_NAMESPACE::Bool32 fullDrawIndexUint32_ = {}, VULKAN_HPP_NAMESPACE::Bool32 imageCubeArray_ = {}, @@ -32173,6 +34029,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceFeatures*>( this ); @@ -32183,6 +34040,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceFeatures const& ) const = default; #else @@ -32251,6 +34109,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess = {}; VULKAN_HPP_NAMESPACE::Bool32 fullDrawIndexUint32 = {}; @@ -32307,12 +34167,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 sparseResidencyAliased = {}; VULKAN_HPP_NAMESPACE::Bool32 variableMultisampleRate = {}; VULKAN_HPP_NAMESPACE::Bool32 inheritedQueries = {}; + }; static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceFeatures>::value, "struct wrapper is not a standard layout!" ); struct DeviceCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceCreateInfo; + VULKAN_HPP_CONSTEXPR DeviceCreateInfo( VULKAN_HPP_NAMESPACE::DeviceCreateFlags flags_ = {}, uint32_t queueCreateInfoCount_ = {}, const VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo* pQueueCreateInfos_ = {}, @@ -32402,6 +34265,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceCreateInfo*>( this ); @@ -32412,6 +34276,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceCreateInfo const& ) const = default; #else @@ -32435,6 +34300,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceCreateInfo; const void* pNext = {}; @@ -32446,12 +34313,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t enabledExtensionCount = {}; const char* const* ppEnabledExtensionNames = {}; const VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures* pEnabledFeatures = {}; + }; static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceCreateInfo> + { + using Type = DeviceCreateInfo; + }; + struct DeviceDiagnosticsConfigCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceDiagnosticsConfigCreateInfoNV; + VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigCreateInfoNV( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV flags_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) {} @@ -32485,6 +34361,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceDiagnosticsConfigCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>( this ); @@ -32495,6 +34372,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceDiagnosticsConfigCreateInfoNV const& ) const = default; #else @@ -32511,16 +34389,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceDiagnosticsConfigCreateInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV flags = {}; + }; static_assert( sizeof( DeviceDiagnosticsConfigCreateInfoNV ) == sizeof( VkDeviceDiagnosticsConfigCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceDiagnosticsConfigCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceDiagnosticsConfigCreateInfoNV> + { + using Type = DeviceDiagnosticsConfigCreateInfoNV; + }; + struct DeviceEventInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceEventInfoEXT; + VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT deviceEvent_ = VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT::eDisplayHotplug ) VULKAN_HPP_NOEXCEPT : deviceEvent( deviceEvent_ ) {} @@ -32554,6 +34443,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceEventInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceEventInfoEXT*>( this ); @@ -32564,6 +34454,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceEventInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceEventInfoEXT const& ) const = default; #else @@ -32580,16 +34471,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceEventInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT deviceEvent = VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT::eDisplayHotplug; + }; static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceEventInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceEventInfoEXT> + { + using Type = DeviceEventInfoEXT; + }; + struct DeviceGroupBindSparseInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupBindSparseInfo; + VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = {}, uint32_t memoryDeviceIndex_ = {} ) VULKAN_HPP_NOEXCEPT : resourceDeviceIndex( resourceDeviceIndex_ ) @@ -32631,6 +34533,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceGroupBindSparseInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceGroupBindSparseInfo*>( this ); @@ -32641,6 +34544,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceGroupBindSparseInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceGroupBindSparseInfo const& ) const = default; #else @@ -32658,17 +34562,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupBindSparseInfo; const void* pNext = {}; uint32_t resourceDeviceIndex = {}; uint32_t memoryDeviceIndex = {}; + }; static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceGroupBindSparseInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceGroupBindSparseInfo> + { + using Type = DeviceGroupBindSparseInfo; + }; + struct DeviceGroupCommandBufferBeginInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupCommandBufferBeginInfo; + VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = {} ) VULKAN_HPP_NOEXCEPT : deviceMask( deviceMask_ ) {} @@ -32702,6 +34617,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceGroupCommandBufferBeginInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>( this ); @@ -32712,6 +34628,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceGroupCommandBufferBeginInfo const& ) const = default; #else @@ -32728,16 +34645,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo; const void* pNext = {}; uint32_t deviceMask = {}; + }; static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceGroupCommandBufferBeginInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceGroupCommandBufferBeginInfo> + { + using Type = DeviceGroupCommandBufferBeginInfo; + }; + struct DeviceGroupDeviceCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupDeviceCreateInfo; + VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = {}, const VULKAN_HPP_NAMESPACE::PhysicalDevice* pPhysicalDevices_ = {} ) VULKAN_HPP_NOEXCEPT : physicalDeviceCount( physicalDeviceCount_ ) @@ -32779,6 +34707,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceGroupDeviceCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>( this ); @@ -32789,6 +34718,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceGroupDeviceCreateInfo const& ) const = default; #else @@ -32806,17 +34736,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo; const void* pNext = {}; uint32_t physicalDeviceCount = {}; const VULKAN_HPP_NAMESPACE::PhysicalDevice* pPhysicalDevices = {}; + }; static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceGroupDeviceCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceGroupDeviceCreateInfo> + { + using Type = DeviceGroupDeviceCreateInfo; + }; + struct DeviceGroupPresentCapabilitiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupPresentCapabilitiesKHR; + VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentCapabilitiesKHR( std::array<uint32_t,VK_MAX_DEVICE_GROUP_SIZE> const& presentMask_ = {}, VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes_ = {} ) VULKAN_HPP_NOEXCEPT : presentMask( presentMask_ ) @@ -32840,6 +34781,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceGroupPresentCapabilitiesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR*>( this ); @@ -32850,6 +34792,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceGroupPresentCapabilitiesKHR const& ) const = default; #else @@ -32867,17 +34810,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, VK_MAX_DEVICE_GROUP_SIZE> presentMask = {}; VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes = {}; + }; static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceGroupPresentCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceGroupPresentCapabilitiesKHR> + { + using Type = DeviceGroupPresentCapabilitiesKHR; + }; + struct DeviceGroupPresentInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupPresentInfoKHR; + VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = {}, const uint32_t* pDeviceMasks_ = {}, VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR mode_ = VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR::eLocal ) VULKAN_HPP_NOEXCEPT @@ -32927,6 +34881,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceGroupPresentInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>( this ); @@ -32937,6 +34892,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceGroupPresentInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceGroupPresentInfoKHR const& ) const = default; #else @@ -32955,18 +34911,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupPresentInfoKHR; const void* pNext = {}; uint32_t swapchainCount = {}; const uint32_t* pDeviceMasks = {}; VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR mode = VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR::eLocal; + }; static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceGroupPresentInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceGroupPresentInfoKHR> + { + using Type = DeviceGroupPresentInfoKHR; + }; + struct DeviceGroupRenderPassBeginInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupRenderPassBeginInfo; + VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = {}, uint32_t deviceRenderAreaCount_ = {}, const VULKAN_HPP_NAMESPACE::Rect2D* pDeviceRenderAreas_ = {} ) VULKAN_HPP_NOEXCEPT @@ -33016,6 +34983,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceGroupRenderPassBeginInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>( this ); @@ -33026,6 +34994,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceGroupRenderPassBeginInfo const& ) const = default; #else @@ -33044,18 +35013,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo; const void* pNext = {}; uint32_t deviceMask = {}; uint32_t deviceRenderAreaCount = {}; const VULKAN_HPP_NAMESPACE::Rect2D* pDeviceRenderAreas = {}; + }; static_assert( sizeof( DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceGroupRenderPassBeginInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceGroupRenderPassBeginInfo> + { + using Type = DeviceGroupRenderPassBeginInfo; + }; + struct DeviceGroupSubmitInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupSubmitInfo; + VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = {}, const uint32_t* pWaitSemaphoreDeviceIndices_ = {}, uint32_t commandBufferCount_ = {}, @@ -33129,6 +35109,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceGroupSubmitInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceGroupSubmitInfo*>( this ); @@ -33139,6 +35120,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceGroupSubmitInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceGroupSubmitInfo const& ) const = default; #else @@ -33160,6 +35142,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupSubmitInfo; const void* pNext = {}; @@ -33169,12 +35153,21 @@ namespace VULKAN_HPP_NAMESPACE const uint32_t* pCommandBufferDeviceMasks = {}; uint32_t signalSemaphoreCount = {}; const uint32_t* pSignalSemaphoreDeviceIndices = {}; + }; static_assert( sizeof( DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceGroupSubmitInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceGroupSubmitInfo> + { + using Type = DeviceGroupSubmitInfo; + }; + struct DeviceGroupSwapchainCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupSwapchainCreateInfoKHR; + VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes_ = {} ) VULKAN_HPP_NOEXCEPT : modes( modes_ ) {} @@ -33208,6 +35201,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceGroupSwapchainCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>( this ); @@ -33218,6 +35212,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceGroupSwapchainCreateInfoKHR const& ) const = default; #else @@ -33234,16 +35229,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes = {}; + }; static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceGroupSwapchainCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceGroupSwapchainCreateInfoKHR> + { + using Type = DeviceGroupSwapchainCreateInfoKHR; + }; + struct DeviceMemoryOpaqueCaptureAddressInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryOpaqueCaptureAddressInfo; + VULKAN_HPP_CONSTEXPR DeviceMemoryOpaqueCaptureAddressInfo( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {} ) VULKAN_HPP_NOEXCEPT : memory( memory_ ) {} @@ -33277,6 +35283,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceMemoryOpaqueCaptureAddressInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo*>( this ); @@ -33287,6 +35294,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceMemoryOpaqueCaptureAddressInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceMemoryOpaqueCaptureAddressInfo const& ) const = default; #else @@ -33303,16 +35311,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceMemoryOpaqueCaptureAddressInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceMemory memory = {}; + }; static_assert( sizeof( DeviceMemoryOpaqueCaptureAddressInfo ) == sizeof( VkDeviceMemoryOpaqueCaptureAddressInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceMemoryOpaqueCaptureAddressInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceMemoryOpaqueCaptureAddressInfo> + { + using Type = DeviceMemoryOpaqueCaptureAddressInfo; + }; + struct DeviceMemoryOverallocationCreateInfoAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD; + VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD overallocationBehavior_ = VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD::eDefault ) VULKAN_HPP_NOEXCEPT : overallocationBehavior( overallocationBehavior_ ) {} @@ -33346,6 +35365,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceMemoryOverallocationCreateInfoAMD const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>( this ); @@ -33356,6 +35376,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceMemoryOverallocationCreateInfoAMD const& ) const = default; #else @@ -33372,16 +35393,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD; const void* pNext = {}; VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD overallocationBehavior = VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD::eDefault; + }; static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceMemoryOverallocationCreateInfoAMD>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceMemoryOverallocationCreateInfoAMD> + { + using Type = DeviceMemoryOverallocationCreateInfoAMD; + }; + struct DeviceQueueGlobalPriorityCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT; + VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfoEXT( VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT globalPriority_ = VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT::eLow ) VULKAN_HPP_NOEXCEPT : globalPriority( globalPriority_ ) {} @@ -33415,6 +35447,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceQueueGlobalPriorityCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>( this ); @@ -33425,6 +35458,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceQueueGlobalPriorityCreateInfoEXT const& ) const = default; #else @@ -33441,16 +35475,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT globalPriority = VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT::eLow; + }; static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceQueueGlobalPriorityCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT> + { + using Type = DeviceQueueGlobalPriorityCreateInfoEXT; + }; + struct DeviceQueueInfo2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueInfo2; + VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags flags_ = {}, uint32_t queueFamilyIndex_ = {}, uint32_t queueIndex_ = {} ) VULKAN_HPP_NOEXCEPT @@ -33500,6 +35545,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDeviceQueueInfo2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDeviceQueueInfo2*>( this ); @@ -33510,6 +35556,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDeviceQueueInfo2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DeviceQueueInfo2 const& ) const = default; #else @@ -33528,18 +35575,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceQueueInfo2; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags flags = {}; uint32_t queueFamilyIndex = {}; uint32_t queueIndex = {}; + }; static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DeviceQueueInfo2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDeviceQueueInfo2> + { + using Type = DeviceQueueInfo2; + }; + struct DispatchIndirectCommand { + VULKAN_HPP_CONSTEXPR DispatchIndirectCommand( uint32_t x_ = {}, uint32_t y_ = {}, uint32_t z_ = {} ) VULKAN_HPP_NOEXCEPT @@ -33577,6 +35634,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDispatchIndirectCommand const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDispatchIndirectCommand*>( this ); @@ -33587,6 +35645,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDispatchIndirectCommand*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DispatchIndirectCommand const& ) const = default; #else @@ -33603,16 +35662,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t x = {}; uint32_t y = {}; uint32_t z = {}; + }; static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DispatchIndirectCommand>::value, "struct wrapper is not a standard layout!" ); struct DisplayEventInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayEventInfoEXT; + VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT displayEvent_ = VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT::eFirstPixelOut ) VULKAN_HPP_NOEXCEPT : displayEvent( displayEvent_ ) {} @@ -33646,6 +35710,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDisplayEventInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayEventInfoEXT*>( this ); @@ -33656,6 +35721,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayEventInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayEventInfoEXT const& ) const = default; #else @@ -33672,16 +35738,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayEventInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT displayEvent = VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT::eFirstPixelOut; + }; static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayEventInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDisplayEventInfoEXT> + { + using Type = DisplayEventInfoEXT; + }; + struct DisplayModeParametersKHR { + VULKAN_HPP_CONSTEXPR DisplayModeParametersKHR( VULKAN_HPP_NAMESPACE::Extent2D visibleRegion_ = {}, uint32_t refreshRate_ = {} ) VULKAN_HPP_NOEXCEPT : visibleRegion( visibleRegion_ ) @@ -33699,7 +35775,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - DisplayModeParametersKHR & setVisibleRegion( VULKAN_HPP_NAMESPACE::Extent2D visibleRegion_ ) VULKAN_HPP_NOEXCEPT + DisplayModeParametersKHR & setVisibleRegion( VULKAN_HPP_NAMESPACE::Extent2D const & visibleRegion_ ) VULKAN_HPP_NOEXCEPT { visibleRegion = visibleRegion_; return *this; @@ -33711,6 +35787,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDisplayModeParametersKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayModeParametersKHR*>( this ); @@ -33721,6 +35798,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayModeParametersKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayModeParametersKHR const& ) const = default; #else @@ -33736,15 +35814,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Extent2D visibleRegion = {}; uint32_t refreshRate = {}; + }; static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayModeParametersKHR>::value, "struct wrapper is not a standard layout!" ); struct DisplayModeCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayModeCreateInfoKHR; + VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR flags_ = {}, VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -33780,12 +35863,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - DisplayModeCreateInfoKHR & setParameters( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters_ ) VULKAN_HPP_NOEXCEPT + DisplayModeCreateInfoKHR & setParameters( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & parameters_ ) VULKAN_HPP_NOEXCEPT { parameters = parameters_; return *this; } + operator VkDisplayModeCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( this ); @@ -33796,6 +35880,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayModeCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayModeCreateInfoKHR const& ) const = default; #else @@ -33813,17 +35898,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayModeCreateInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR flags = {}; VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters = {}; + }; static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayModeCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDisplayModeCreateInfoKHR> + { + using Type = DisplayModeCreateInfoKHR; + }; + struct DisplayModePropertiesKHR { + VULKAN_HPP_CONSTEXPR DisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR displayMode_ = {}, VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters_ = {} ) VULKAN_HPP_NOEXCEPT : displayMode( displayMode_ ) @@ -33841,6 +35936,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDisplayModePropertiesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayModePropertiesKHR*>( this ); @@ -33851,6 +35947,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayModePropertiesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayModePropertiesKHR const& ) const = default; #else @@ -33866,15 +35963,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::DisplayModeKHR displayMode = {}; VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR parameters = {}; + }; static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayModePropertiesKHR>::value, "struct wrapper is not a standard layout!" ); struct DisplayModeProperties2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayModeProperties2KHR; + VULKAN_HPP_CONSTEXPR DisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR displayModeProperties_ = {} ) VULKAN_HPP_NOEXCEPT : displayModeProperties( displayModeProperties_ ) {} @@ -33896,6 +35998,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDisplayModeProperties2KHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayModeProperties2KHR*>( this ); @@ -33906,6 +36009,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayModeProperties2KHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayModeProperties2KHR const& ) const = default; #else @@ -33922,16 +36026,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayModeProperties2KHR; void* pNext = {}; VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR displayModeProperties = {}; + }; static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayModeProperties2KHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDisplayModeProperties2KHR> + { + using Type = DisplayModeProperties2KHR; + }; + struct DisplayNativeHdrSurfaceCapabilitiesAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD; + VULKAN_HPP_CONSTEXPR DisplayNativeHdrSurfaceCapabilitiesAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingSupport_ = {} ) VULKAN_HPP_NOEXCEPT : localDimmingSupport( localDimmingSupport_ ) {} @@ -33953,6 +36068,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>( this ); @@ -33963,6 +36079,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayNativeHdrSurfaceCapabilitiesAMD const& ) const = default; #else @@ -33979,16 +36096,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 localDimmingSupport = {}; + }; static_assert( sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayNativeHdrSurfaceCapabilitiesAMD>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD> + { + using Type = DisplayNativeHdrSurfaceCapabilitiesAMD; + }; + struct DisplayPlaneCapabilitiesKHR { + VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR supportedAlpha_ = {}, VULKAN_HPP_NAMESPACE::Offset2D minSrcPosition_ = {}, VULKAN_HPP_NAMESPACE::Offset2D maxSrcPosition_ = {}, @@ -34020,6 +36147,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDisplayPlaneCapabilitiesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>( this ); @@ -34030,6 +36158,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayPlaneCapabilitiesKHR const& ) const = default; #else @@ -34052,6 +36181,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR supportedAlpha = {}; VULKAN_HPP_NAMESPACE::Offset2D minSrcPosition = {}; @@ -34062,12 +36193,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Offset2D maxDstPosition = {}; VULKAN_HPP_NAMESPACE::Extent2D minDstExtent = {}; VULKAN_HPP_NAMESPACE::Extent2D maxDstExtent = {}; + }; static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayPlaneCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" ); struct DisplayPlaneCapabilities2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneCapabilities2KHR; + VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilities2KHR( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities_ = {} ) VULKAN_HPP_NOEXCEPT : capabilities( capabilities_ ) {} @@ -34089,6 +36223,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDisplayPlaneCapabilities2KHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayPlaneCapabilities2KHR*>( this ); @@ -34099,6 +36234,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayPlaneCapabilities2KHR const& ) const = default; #else @@ -34115,16 +36251,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR; void* pNext = {}; VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities = {}; + }; static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayPlaneCapabilities2KHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDisplayPlaneCapabilities2KHR> + { + using Type = DisplayPlaneCapabilities2KHR; + }; + struct DisplayPlaneInfo2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneInfo2KHR; + VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode_ = {}, uint32_t planeIndex_ = {} ) VULKAN_HPP_NOEXCEPT : mode( mode_ ) @@ -34166,6 +36313,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDisplayPlaneInfo2KHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayPlaneInfo2KHR*>( this ); @@ -34176,6 +36324,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayPlaneInfo2KHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayPlaneInfo2KHR const& ) const = default; #else @@ -34193,17 +36342,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPlaneInfo2KHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DisplayModeKHR mode = {}; uint32_t planeIndex = {}; + }; static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayPlaneInfo2KHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDisplayPlaneInfo2KHR> + { + using Type = DisplayPlaneInfo2KHR; + }; + struct DisplayPlanePropertiesKHR { + VULKAN_HPP_CONSTEXPR DisplayPlanePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR currentDisplay_ = {}, uint32_t currentStackIndex_ = {} ) VULKAN_HPP_NOEXCEPT : currentDisplay( currentDisplay_ ) @@ -34221,6 +36380,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDisplayPlanePropertiesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayPlanePropertiesKHR*>( this ); @@ -34231,6 +36391,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayPlanePropertiesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayPlanePropertiesKHR const& ) const = default; #else @@ -34246,15 +36407,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::DisplayKHR currentDisplay = {}; uint32_t currentStackIndex = {}; + }; static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayPlanePropertiesKHR>::value, "struct wrapper is not a standard layout!" ); struct DisplayPlaneProperties2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneProperties2KHR; + VULKAN_HPP_CONSTEXPR DisplayPlaneProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR displayPlaneProperties_ = {} ) VULKAN_HPP_NOEXCEPT : displayPlaneProperties( displayPlaneProperties_ ) {} @@ -34276,6 +36442,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDisplayPlaneProperties2KHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayPlaneProperties2KHR*>( this ); @@ -34286,6 +36453,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayPlaneProperties2KHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayPlaneProperties2KHR const& ) const = default; #else @@ -34302,16 +36470,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPlaneProperties2KHR; void* pNext = {}; VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR displayPlaneProperties = {}; + }; static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayPlaneProperties2KHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDisplayPlaneProperties2KHR> + { + using Type = DisplayPlaneProperties2KHR; + }; + struct DisplayPowerInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPowerInfoEXT; + VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT powerState_ = VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT::eOff ) VULKAN_HPP_NOEXCEPT : powerState( powerState_ ) {} @@ -34345,6 +36524,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDisplayPowerInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayPowerInfoEXT*>( this ); @@ -34355,6 +36535,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayPowerInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayPowerInfoEXT const& ) const = default; #else @@ -34371,16 +36552,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPowerInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT powerState = VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT::eOff; + }; static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayPowerInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDisplayPowerInfoEXT> + { + using Type = DisplayPowerInfoEXT; + }; + struct DisplayPresentInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPresentInfoKHR; + VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( VULKAN_HPP_NAMESPACE::Rect2D srcRect_ = {}, VULKAN_HPP_NAMESPACE::Rect2D dstRect_ = {}, VULKAN_HPP_NAMESPACE::Bool32 persistent_ = {} ) VULKAN_HPP_NOEXCEPT @@ -34412,13 +36604,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - DisplayPresentInfoKHR & setSrcRect( VULKAN_HPP_NAMESPACE::Rect2D srcRect_ ) VULKAN_HPP_NOEXCEPT + DisplayPresentInfoKHR & setSrcRect( VULKAN_HPP_NAMESPACE::Rect2D const & srcRect_ ) VULKAN_HPP_NOEXCEPT { srcRect = srcRect_; return *this; } - DisplayPresentInfoKHR & setDstRect( VULKAN_HPP_NAMESPACE::Rect2D dstRect_ ) VULKAN_HPP_NOEXCEPT + DisplayPresentInfoKHR & setDstRect( VULKAN_HPP_NAMESPACE::Rect2D const & dstRect_ ) VULKAN_HPP_NOEXCEPT { dstRect = dstRect_; return *this; @@ -34430,6 +36622,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDisplayPresentInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayPresentInfoKHR*>( this ); @@ -34440,6 +36633,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayPresentInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayPresentInfoKHR const& ) const = default; #else @@ -34458,18 +36652,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayPresentInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Rect2D srcRect = {}; VULKAN_HPP_NAMESPACE::Rect2D dstRect = {}; VULKAN_HPP_NAMESPACE::Bool32 persistent = {}; + }; static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayPresentInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDisplayPresentInfoKHR> + { + using Type = DisplayPresentInfoKHR; + }; + struct DisplayPropertiesKHR { + VULKAN_HPP_CONSTEXPR DisplayPropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display_ = {}, const char* displayName_ = {}, VULKAN_HPP_NAMESPACE::Extent2D physicalDimensions_ = {}, @@ -34497,6 +36701,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDisplayPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayPropertiesKHR*>( this ); @@ -34507,6 +36712,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayPropertiesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayPropertiesKHR const& ) const = default; #else @@ -34527,6 +36733,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::DisplayKHR display = {}; const char* displayName = {}; @@ -34535,12 +36743,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR supportedTransforms = {}; VULKAN_HPP_NAMESPACE::Bool32 planeReorderPossible = {}; VULKAN_HPP_NAMESPACE::Bool32 persistentContent = {}; + }; static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayPropertiesKHR>::value, "struct wrapper is not a standard layout!" ); struct DisplayProperties2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayProperties2KHR; + VULKAN_HPP_CONSTEXPR DisplayProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR displayProperties_ = {} ) VULKAN_HPP_NOEXCEPT : displayProperties( displayProperties_ ) {} @@ -34562,6 +36773,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDisplayProperties2KHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplayProperties2KHR*>( this ); @@ -34572,6 +36784,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplayProperties2KHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplayProperties2KHR const& ) const = default; #else @@ -34588,16 +36801,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplayProperties2KHR; void* pNext = {}; VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR displayProperties = {}; + }; static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplayProperties2KHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDisplayProperties2KHR> + { + using Type = DisplayProperties2KHR; + }; + struct DisplaySurfaceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplaySurfaceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR flags_ = {}, VULKAN_HPP_NAMESPACE::DisplayModeKHR displayMode_ = {}, uint32_t planeIndex_ = {}, @@ -34681,12 +36905,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - DisplaySurfaceCreateInfoKHR & setImageExtent( VULKAN_HPP_NAMESPACE::Extent2D imageExtent_ ) VULKAN_HPP_NOEXCEPT + DisplaySurfaceCreateInfoKHR & setImageExtent( VULKAN_HPP_NAMESPACE::Extent2D const & imageExtent_ ) VULKAN_HPP_NOEXCEPT { imageExtent = imageExtent_; return *this; } + operator VkDisplaySurfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( this ); @@ -34697,6 +36922,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DisplaySurfaceCreateInfoKHR const& ) const = default; #else @@ -34720,6 +36946,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR; const void* pNext = {}; @@ -34731,12 +36959,20 @@ namespace VULKAN_HPP_NAMESPACE float globalAlpha = {}; VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR alphaMode = VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR::eOpaque; VULKAN_HPP_NAMESPACE::Extent2D imageExtent = {}; + }; static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DisplaySurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDisplaySurfaceCreateInfoKHR> + { + using Type = DisplaySurfaceCreateInfoKHR; + }; + struct DrawIndexedIndirectCommand { + VULKAN_HPP_CONSTEXPR DrawIndexedIndirectCommand( uint32_t indexCount_ = {}, uint32_t instanceCount_ = {}, uint32_t firstIndex_ = {}, @@ -34790,6 +37026,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDrawIndexedIndirectCommand const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDrawIndexedIndirectCommand*>( this ); @@ -34800,6 +37037,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDrawIndexedIndirectCommand*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DrawIndexedIndirectCommand const& ) const = default; #else @@ -34818,18 +37056,22 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t indexCount = {}; uint32_t instanceCount = {}; uint32_t firstIndex = {}; int32_t vertexOffset = {}; uint32_t firstInstance = {}; + }; static_assert( sizeof( DrawIndexedIndirectCommand ) == sizeof( VkDrawIndexedIndirectCommand ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DrawIndexedIndirectCommand>::value, "struct wrapper is not a standard layout!" ); struct DrawIndirectCommand { + VULKAN_HPP_CONSTEXPR DrawIndirectCommand( uint32_t vertexCount_ = {}, uint32_t instanceCount_ = {}, uint32_t firstVertex_ = {}, @@ -34875,6 +37117,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDrawIndirectCommand const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDrawIndirectCommand*>( this ); @@ -34885,6 +37128,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDrawIndirectCommand*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DrawIndirectCommand const& ) const = default; #else @@ -34902,17 +37146,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t vertexCount = {}; uint32_t instanceCount = {}; uint32_t firstVertex = {}; uint32_t firstInstance = {}; + }; static_assert( sizeof( DrawIndirectCommand ) == sizeof( VkDrawIndirectCommand ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DrawIndirectCommand>::value, "struct wrapper is not a standard layout!" ); struct DrawMeshTasksIndirectCommandNV { + VULKAN_HPP_CONSTEXPR DrawMeshTasksIndirectCommandNV( uint32_t taskCount_ = {}, uint32_t firstTask_ = {} ) VULKAN_HPP_NOEXCEPT : taskCount( taskCount_ ) @@ -34942,6 +37190,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDrawMeshTasksIndirectCommandNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDrawMeshTasksIndirectCommandNV*>( this ); @@ -34952,6 +37201,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DrawMeshTasksIndirectCommandNV const& ) const = default; #else @@ -34967,15 +37217,19 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t taskCount = {}; uint32_t firstTask = {}; + }; static_assert( sizeof( DrawMeshTasksIndirectCommandNV ) == sizeof( VkDrawMeshTasksIndirectCommandNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DrawMeshTasksIndirectCommandNV>::value, "struct wrapper is not a standard layout!" ); struct DrmFormatModifierPropertiesEXT { + VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = {}, uint32_t drmFormatModifierPlaneCount_ = {}, VULKAN_HPP_NAMESPACE::FormatFeatureFlags drmFormatModifierTilingFeatures_ = {} ) VULKAN_HPP_NOEXCEPT @@ -34995,6 +37249,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDrmFormatModifierPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDrmFormatModifierPropertiesEXT*>( this ); @@ -35005,6 +37260,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDrmFormatModifierPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DrmFormatModifierPropertiesEXT const& ) const = default; #else @@ -35021,16 +37277,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint64_t drmFormatModifier = {}; uint32_t drmFormatModifierPlaneCount = {}; VULKAN_HPP_NAMESPACE::FormatFeatureFlags drmFormatModifierTilingFeatures = {}; + }; static_assert( sizeof( DrmFormatModifierPropertiesEXT ) == sizeof( VkDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DrmFormatModifierPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); struct DrmFormatModifierPropertiesListEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDrmFormatModifierPropertiesListEXT; + VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesListEXT( uint32_t drmFormatModifierCount_ = {}, VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties_ = {} ) VULKAN_HPP_NOEXCEPT : drmFormatModifierCount( drmFormatModifierCount_ ) @@ -35054,6 +37315,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkDrmFormatModifierPropertiesListEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>( this ); @@ -35064,6 +37326,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( DrmFormatModifierPropertiesListEXT const& ) const = default; #else @@ -35081,17 +37344,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT; void* pNext = {}; uint32_t drmFormatModifierCount = {}; VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties = {}; + }; static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<DrmFormatModifierPropertiesListEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eDrmFormatModifierPropertiesListEXT> + { + using Type = DrmFormatModifierPropertiesListEXT; + }; + struct EventCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eEventCreateInfo; + VULKAN_HPP_CONSTEXPR EventCreateInfo( VULKAN_HPP_NAMESPACE::EventCreateFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) {} @@ -35125,6 +37399,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkEventCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkEventCreateInfo*>( this ); @@ -35135,6 +37410,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkEventCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( EventCreateInfo const& ) const = default; #else @@ -35151,16 +37427,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eEventCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::EventCreateFlags flags = {}; + }; static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<EventCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eEventCreateInfo> + { + using Type = EventCreateInfo; + }; + struct ExportFenceCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportFenceCreateInfo; + VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT : handleTypes( handleTypes_ ) {} @@ -35194,6 +37481,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExportFenceCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExportFenceCreateInfo*>( this ); @@ -35204,6 +37492,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExportFenceCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExportFenceCreateInfo const& ) const = default; #else @@ -35220,17 +37509,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportFenceCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags handleTypes = {}; + }; static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExportFenceCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eExportFenceCreateInfo> + { + using Type = ExportFenceCreateInfo; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct ExportFenceWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportFenceWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = {}, DWORD dwAccess_ = {}, LPCWSTR name_ = {} ) VULKAN_HPP_NOEXCEPT @@ -35280,6 +37580,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExportFenceWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>( this ); @@ -35290,6 +37591,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExportFenceWin32HandleInfoKHR const& ) const = default; #else @@ -35308,19 +37610,30 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR; const void* pNext = {}; const SECURITY_ATTRIBUTES* pAttributes = {}; DWORD dwAccess = {}; LPCWSTR name = {}; + }; static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExportFenceWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eExportFenceWin32HandleInfoKHR> + { + using Type = ExportFenceWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ExportMemoryAllocateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryAllocateInfo; + VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT : handleTypes( handleTypes_ ) {} @@ -35354,6 +37667,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExportMemoryAllocateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExportMemoryAllocateInfo*>( this ); @@ -35364,6 +37678,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExportMemoryAllocateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExportMemoryAllocateInfo const& ) const = default; #else @@ -35380,16 +37695,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportMemoryAllocateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes = {}; + }; static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExportMemoryAllocateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eExportMemoryAllocateInfo> + { + using Type = ExportMemoryAllocateInfo; + }; + struct ExportMemoryAllocateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryAllocateInfoNV; + VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT : handleTypes( handleTypes_ ) {} @@ -35423,6 +37749,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExportMemoryAllocateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>( this ); @@ -35433,6 +37760,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExportMemoryAllocateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExportMemoryAllocateInfoNV const& ) const = default; #else @@ -35449,17 +37777,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportMemoryAllocateInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleTypes = {}; + }; static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExportMemoryAllocateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eExportMemoryAllocateInfoNV> + { + using Type = ExportMemoryAllocateInfoNV; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct ExportMemoryWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = {}, DWORD dwAccess_ = {}, LPCWSTR name_ = {} ) VULKAN_HPP_NOEXCEPT @@ -35509,6 +37848,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExportMemoryWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>( this ); @@ -35519,6 +37859,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExportMemoryWin32HandleInfoKHR const& ) const = default; #else @@ -35537,20 +37878,31 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR; const void* pNext = {}; const SECURITY_ATTRIBUTES* pAttributes = {}; DWORD dwAccess = {}; LPCWSTR name = {}; + }; static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExportMemoryWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eExportMemoryWin32HandleInfoKHR> + { + using Type = ExportMemoryWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR struct ExportMemoryWin32HandleInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryWin32HandleInfoNV; + VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = {}, DWORD dwAccess_ = {} ) VULKAN_HPP_NOEXCEPT : pAttributes( pAttributes_ ) @@ -35592,6 +37944,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExportMemoryWin32HandleInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>( this ); @@ -35602,6 +37955,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExportMemoryWin32HandleInfoNV const& ) const = default; #else @@ -35619,18 +37973,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV; const void* pNext = {}; const SECURITY_ATTRIBUTES* pAttributes = {}; DWORD dwAccess = {}; + }; static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExportMemoryWin32HandleInfoNV>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eExportMemoryWin32HandleInfoNV> + { + using Type = ExportMemoryWin32HandleInfoNV; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ExportSemaphoreCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportSemaphoreCreateInfo; + VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT : handleTypes( handleTypes_ ) {} @@ -35664,6 +38029,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExportSemaphoreCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExportSemaphoreCreateInfo*>( this ); @@ -35674,6 +38040,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExportSemaphoreCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExportSemaphoreCreateInfo const& ) const = default; #else @@ -35690,17 +38057,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportSemaphoreCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags handleTypes = {}; + }; static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExportSemaphoreCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eExportSemaphoreCreateInfo> + { + using Type = ExportSemaphoreCreateInfo; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct ExportSemaphoreWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportSemaphoreWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = {}, DWORD dwAccess_ = {}, LPCWSTR name_ = {} ) VULKAN_HPP_NOEXCEPT @@ -35750,6 +38128,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExportSemaphoreWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>( this ); @@ -35760,6 +38139,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExportSemaphoreWin32HandleInfoKHR const& ) const = default; #else @@ -35778,19 +38158,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR; const void* pNext = {}; const SECURITY_ATTRIBUTES* pAttributes = {}; DWORD dwAccess = {}; LPCWSTR name = {}; + }; static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExportSemaphoreWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eExportSemaphoreWin32HandleInfoKHR> + { + using Type = ExportSemaphoreWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ExtensionProperties { + VULKAN_HPP_CONSTEXPR_14 ExtensionProperties( std::array<char,VK_MAX_EXTENSION_NAME_SIZE> const& extensionName_ = {}, uint32_t specVersion_ = {} ) VULKAN_HPP_NOEXCEPT : extensionName( extensionName_ ) @@ -35808,6 +38198,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExtensionProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExtensionProperties*>( this ); @@ -35818,6 +38209,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExtensionProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExtensionProperties const& ) const = default; #else @@ -35833,15 +38225,19 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> extensionName = {}; uint32_t specVersion = {}; + }; static_assert( sizeof( ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExtensionProperties>::value, "struct wrapper is not a standard layout!" ); struct ExternalMemoryProperties { + VULKAN_HPP_CONSTEXPR ExternalMemoryProperties( VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags externalMemoryFeatures_ = {}, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes_ = {}, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags compatibleHandleTypes_ = {} ) VULKAN_HPP_NOEXCEPT @@ -35861,6 +38257,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExternalMemoryProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExternalMemoryProperties*>( this ); @@ -35871,6 +38268,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExternalMemoryProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExternalMemoryProperties const& ) const = default; #else @@ -35887,16 +38285,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags externalMemoryFeatures = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags compatibleHandleTypes = {}; + }; static_assert( sizeof( ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExternalMemoryProperties>::value, "struct wrapper is not a standard layout!" ); struct ExternalBufferProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalBufferProperties; + VULKAN_HPP_CONSTEXPR ExternalBufferProperties( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties externalMemoryProperties_ = {} ) VULKAN_HPP_NOEXCEPT : externalMemoryProperties( externalMemoryProperties_ ) {} @@ -35918,6 +38321,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExternalBufferProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExternalBufferProperties*>( this ); @@ -35928,6 +38332,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExternalBufferProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExternalBufferProperties const& ) const = default; #else @@ -35944,16 +38349,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalBufferProperties; void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryProperties externalMemoryProperties = {}; + }; static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExternalBufferProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eExternalBufferProperties> + { + using Type = ExternalBufferProperties; + }; + struct ExternalFenceProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalFenceProperties; + VULKAN_HPP_CONSTEXPR ExternalFenceProperties( VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes_ = {}, VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags compatibleHandleTypes_ = {}, VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags externalFenceFeatures_ = {} ) VULKAN_HPP_NOEXCEPT @@ -35979,6 +38395,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExternalFenceProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExternalFenceProperties*>( this ); @@ -35989,6 +38406,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExternalFenceProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExternalFenceProperties const& ) const = default; #else @@ -36007,19 +38425,30 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalFenceProperties; void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes = {}; VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags compatibleHandleTypes = {}; VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags externalFenceFeatures = {}; + }; static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExternalFenceProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eExternalFenceProperties> + { + using Type = ExternalFenceProperties; + }; + #ifdef VK_USE_PLATFORM_ANDROID_KHR struct ExternalFormatANDROID { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalFormatANDROID; + VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( uint64_t externalFormat_ = {} ) VULKAN_HPP_NOEXCEPT : externalFormat( externalFormat_ ) {} @@ -36053,6 +38482,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExternalFormatANDROID const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExternalFormatANDROID*>( this ); @@ -36063,6 +38493,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExternalFormatANDROID*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExternalFormatANDROID const& ) const = default; #else @@ -36079,17 +38510,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalFormatANDROID; void* pNext = {}; uint64_t externalFormat = {}; + }; static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExternalFormatANDROID>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eExternalFormatANDROID> + { + using Type = ExternalFormatANDROID; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ struct ExternalImageFormatProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalImageFormatProperties; + VULKAN_HPP_CONSTEXPR ExternalImageFormatProperties( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties externalMemoryProperties_ = {} ) VULKAN_HPP_NOEXCEPT : externalMemoryProperties( externalMemoryProperties_ ) {} @@ -36111,6 +38553,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExternalImageFormatProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExternalImageFormatProperties*>( this ); @@ -36121,6 +38564,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExternalImageFormatProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExternalImageFormatProperties const& ) const = default; #else @@ -36137,16 +38581,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalImageFormatProperties; void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryProperties externalMemoryProperties = {}; + }; static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExternalImageFormatProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eExternalImageFormatProperties> + { + using Type = ExternalImageFormatProperties; + }; + struct ImageFormatProperties { + VULKAN_HPP_CONSTEXPR ImageFormatProperties( VULKAN_HPP_NAMESPACE::Extent3D maxExtent_ = {}, uint32_t maxMipLevels_ = {}, uint32_t maxArrayLayers_ = {}, @@ -36170,6 +38624,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageFormatProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageFormatProperties*>( this ); @@ -36180,6 +38635,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageFormatProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageFormatProperties const& ) const = default; #else @@ -36198,18 +38654,22 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Extent3D maxExtent = {}; uint32_t maxMipLevels = {}; uint32_t maxArrayLayers = {}; VULKAN_HPP_NAMESPACE::SampleCountFlags sampleCounts = {}; VULKAN_HPP_NAMESPACE::DeviceSize maxResourceSize = {}; + }; static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageFormatProperties>::value, "struct wrapper is not a standard layout!" ); struct ExternalImageFormatPropertiesNV { + VULKAN_HPP_CONSTEXPR ExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties_ = {}, VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsNV externalMemoryFeatures_ = {}, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes_ = {}, @@ -36231,6 +38691,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExternalImageFormatPropertiesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>( this ); @@ -36241,6 +38702,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExternalImageFormatPropertiesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExternalImageFormatPropertiesNV const& ) const = default; #else @@ -36258,17 +38720,22 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsNV externalMemoryFeatures = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes = {}; + }; static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExternalImageFormatPropertiesNV>::value, "struct wrapper is not a standard layout!" ); struct ExternalMemoryBufferCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryBufferCreateInfo; + VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT : handleTypes( handleTypes_ ) {} @@ -36302,6 +38769,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExternalMemoryBufferCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>( this ); @@ -36312,6 +38780,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExternalMemoryBufferCreateInfo const& ) const = default; #else @@ -36328,16 +38797,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalMemoryBufferCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes = {}; + }; static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExternalMemoryBufferCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eExternalMemoryBufferCreateInfo> + { + using Type = ExternalMemoryBufferCreateInfo; + }; + struct ExternalMemoryImageCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryImageCreateInfo; + VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT : handleTypes( handleTypes_ ) {} @@ -36371,6 +38851,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExternalMemoryImageCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExternalMemoryImageCreateInfo*>( this ); @@ -36381,6 +38862,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExternalMemoryImageCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExternalMemoryImageCreateInfo const& ) const = default; #else @@ -36397,16 +38879,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalMemoryImageCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags handleTypes = {}; + }; static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExternalMemoryImageCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eExternalMemoryImageCreateInfo> + { + using Type = ExternalMemoryImageCreateInfo; + }; + struct ExternalMemoryImageCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryImageCreateInfoNV; + VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleTypes_ = {} ) VULKAN_HPP_NOEXCEPT : handleTypes( handleTypes_ ) {} @@ -36440,6 +38933,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExternalMemoryImageCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>( this ); @@ -36450,6 +38944,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExternalMemoryImageCreateInfoNV const& ) const = default; #else @@ -36466,16 +38961,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleTypes = {}; + }; static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExternalMemoryImageCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eExternalMemoryImageCreateInfoNV> + { + using Type = ExternalMemoryImageCreateInfoNV; + }; + struct ExternalSemaphoreProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalSemaphoreProperties; + VULKAN_HPP_CONSTEXPR ExternalSemaphoreProperties( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes_ = {}, VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes_ = {}, VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures_ = {} ) VULKAN_HPP_NOEXCEPT @@ -36501,6 +39007,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkExternalSemaphoreProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkExternalSemaphoreProperties*>( this ); @@ -36511,6 +39018,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkExternalSemaphoreProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ExternalSemaphoreProperties const& ) const = default; #else @@ -36529,18 +39037,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalSemaphoreProperties; void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes = {}; VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes = {}; VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures = {}; + }; static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ExternalSemaphoreProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eExternalSemaphoreProperties> + { + using Type = ExternalSemaphoreProperties; + }; + struct FenceCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceCreateInfo; + VULKAN_HPP_CONSTEXPR FenceCreateInfo( VULKAN_HPP_NAMESPACE::FenceCreateFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) {} @@ -36574,6 +39093,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkFenceCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkFenceCreateInfo*>( this ); @@ -36584,6 +39104,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkFenceCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( FenceCreateInfo const& ) const = default; #else @@ -36600,16 +39121,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFenceCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::FenceCreateFlags flags = {}; + }; static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<FenceCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eFenceCreateInfo> + { + using Type = FenceCreateInfo; + }; + struct FenceGetFdInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceGetFdInfoKHR; + VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( VULKAN_HPP_NAMESPACE::Fence fence_ = {}, VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT : fence( fence_ ) @@ -36651,6 +39183,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkFenceGetFdInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkFenceGetFdInfoKHR*>( this ); @@ -36661,6 +39194,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkFenceGetFdInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( FenceGetFdInfoKHR const& ) const = default; #else @@ -36678,18 +39212,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFenceGetFdInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Fence fence = {}; VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd; + }; static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<FenceGetFdInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eFenceGetFdInfoKHR> + { + using Type = FenceGetFdInfoKHR; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct FenceGetWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceGetWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::Fence fence_ = {}, VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT : fence( fence_ ) @@ -36731,6 +39276,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkFenceGetWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( this ); @@ -36741,6 +39287,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( FenceGetWin32HandleInfoKHR const& ) const = default; #else @@ -36758,18 +39305,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Fence fence = {}; VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd; + }; static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<FenceGetWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eFenceGetWin32HandleInfoKHR> + { + using Type = FenceGetWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct FilterCubicImageViewImageFormatPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT; + VULKAN_HPP_CONSTEXPR FilterCubicImageViewImageFormatPropertiesEXT( VULKAN_HPP_NAMESPACE::Bool32 filterCubic_ = {}, VULKAN_HPP_NAMESPACE::Bool32 filterCubicMinmax_ = {} ) VULKAN_HPP_NOEXCEPT : filterCubic( filterCubic_ ) @@ -36793,6 +39351,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkFilterCubicImageViewImageFormatPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>( this ); @@ -36803,6 +39362,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( FilterCubicImageViewImageFormatPropertiesEXT const& ) const = default; #else @@ -36820,17 +39380,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 filterCubic = {}; VULKAN_HPP_NAMESPACE::Bool32 filterCubicMinmax = {}; + }; static_assert( sizeof( FilterCubicImageViewImageFormatPropertiesEXT ) == sizeof( VkFilterCubicImageViewImageFormatPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<FilterCubicImageViewImageFormatPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eFilterCubicImageViewImageFormatPropertiesEXT> + { + using Type = FilterCubicImageViewImageFormatPropertiesEXT; + }; + struct FormatProperties { + VULKAN_HPP_CONSTEXPR FormatProperties( VULKAN_HPP_NAMESPACE::FormatFeatureFlags linearTilingFeatures_ = {}, VULKAN_HPP_NAMESPACE::FormatFeatureFlags optimalTilingFeatures_ = {}, VULKAN_HPP_NAMESPACE::FormatFeatureFlags bufferFeatures_ = {} ) VULKAN_HPP_NOEXCEPT @@ -36850,6 +39420,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkFormatProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkFormatProperties*>( this ); @@ -36860,6 +39431,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkFormatProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( FormatProperties const& ) const = default; #else @@ -36876,16 +39448,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::FormatFeatureFlags linearTilingFeatures = {}; VULKAN_HPP_NAMESPACE::FormatFeatureFlags optimalTilingFeatures = {}; VULKAN_HPP_NAMESPACE::FormatFeatureFlags bufferFeatures = {}; + }; static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<FormatProperties>::value, "struct wrapper is not a standard layout!" ); struct FormatProperties2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFormatProperties2; + VULKAN_HPP_CONSTEXPR FormatProperties2( VULKAN_HPP_NAMESPACE::FormatProperties formatProperties_ = {} ) VULKAN_HPP_NOEXCEPT : formatProperties( formatProperties_ ) {} @@ -36907,6 +39484,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkFormatProperties2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkFormatProperties2*>( this ); @@ -36917,6 +39495,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkFormatProperties2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( FormatProperties2 const& ) const = default; #else @@ -36933,16 +39512,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFormatProperties2; void* pNext = {}; VULKAN_HPP_NAMESPACE::FormatProperties formatProperties = {}; + }; static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<FormatProperties2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eFormatProperties2> + { + using Type = FormatProperties2; + }; + struct FramebufferAttachmentImageInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferAttachmentImageInfo; + VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfo( VULKAN_HPP_NAMESPACE::ImageCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage_ = {}, uint32_t width_ = {}, @@ -37024,6 +39614,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkFramebufferAttachmentImageInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkFramebufferAttachmentImageInfo*>( this ); @@ -37034,6 +39625,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkFramebufferAttachmentImageInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( FramebufferAttachmentImageInfo const& ) const = default; #else @@ -37056,6 +39648,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFramebufferAttachmentImageInfo; const void* pNext = {}; @@ -37066,12 +39660,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t layerCount = {}; uint32_t viewFormatCount = {}; const VULKAN_HPP_NAMESPACE::Format* pViewFormats = {}; + }; static_assert( sizeof( FramebufferAttachmentImageInfo ) == sizeof( VkFramebufferAttachmentImageInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<FramebufferAttachmentImageInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eFramebufferAttachmentImageInfo> + { + using Type = FramebufferAttachmentImageInfo; + }; + struct FramebufferAttachmentsCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferAttachmentsCreateInfo; + VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfo( uint32_t attachmentImageInfoCount_ = {}, const VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo* pAttachmentImageInfos_ = {} ) VULKAN_HPP_NOEXCEPT : attachmentImageInfoCount( attachmentImageInfoCount_ ) @@ -37113,6 +39716,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkFramebufferAttachmentsCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>( this ); @@ -37123,6 +39727,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( FramebufferAttachmentsCreateInfo const& ) const = default; #else @@ -37140,17 +39745,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFramebufferAttachmentsCreateInfo; const void* pNext = {}; uint32_t attachmentImageInfoCount = {}; const VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo* pAttachmentImageInfos = {}; + }; static_assert( sizeof( FramebufferAttachmentsCreateInfo ) == sizeof( VkFramebufferAttachmentsCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<FramebufferAttachmentsCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eFramebufferAttachmentsCreateInfo> + { + using Type = FramebufferAttachmentsCreateInfo; + }; + struct FramebufferCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferCreateInfo; + VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( VULKAN_HPP_NAMESPACE::FramebufferCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::RenderPass renderPass_ = {}, uint32_t attachmentCount_ = {}, @@ -37232,6 +39848,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkFramebufferCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkFramebufferCreateInfo*>( this ); @@ -37242,6 +39859,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkFramebufferCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( FramebufferCreateInfo const& ) const = default; #else @@ -37264,6 +39882,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFramebufferCreateInfo; const void* pNext = {}; @@ -37274,12 +39894,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t width = {}; uint32_t height = {}; uint32_t layers = {}; + }; static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<FramebufferCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eFramebufferCreateInfo> + { + using Type = FramebufferCreateInfo; + }; + struct FramebufferMixedSamplesCombinationNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferMixedSamplesCombinationNV; + VULKAN_HPP_CONSTEXPR FramebufferMixedSamplesCombinationNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode_ = VULKAN_HPP_NAMESPACE::CoverageReductionModeNV::eMerge, VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1, VULKAN_HPP_NAMESPACE::SampleCountFlags depthStencilSamples_ = {}, @@ -37307,6 +39936,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkFramebufferMixedSamplesCombinationNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkFramebufferMixedSamplesCombinationNV*>( this ); @@ -37317,6 +39947,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkFramebufferMixedSamplesCombinationNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( FramebufferMixedSamplesCombinationNV const& ) const = default; #else @@ -37336,6 +39967,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eFramebufferMixedSamplesCombinationNV; void* pNext = {}; @@ -37343,12 +39976,20 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1; VULKAN_HPP_NAMESPACE::SampleCountFlags depthStencilSamples = {}; VULKAN_HPP_NAMESPACE::SampleCountFlags colorSamples = {}; + }; static_assert( sizeof( FramebufferMixedSamplesCombinationNV ) == sizeof( VkFramebufferMixedSamplesCombinationNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<FramebufferMixedSamplesCombinationNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eFramebufferMixedSamplesCombinationNV> + { + using Type = FramebufferMixedSamplesCombinationNV; + }; + struct IndirectCommandsStreamNV { + VULKAN_HPP_CONSTEXPR IndirectCommandsStreamNV( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {} ) VULKAN_HPP_NOEXCEPT : buffer( buffer_ ) @@ -37378,6 +40019,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkIndirectCommandsStreamNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkIndirectCommandsStreamNV*>( this ); @@ -37388,6 +40030,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkIndirectCommandsStreamNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( IndirectCommandsStreamNV const& ) const = default; #else @@ -37403,15 +40046,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Buffer buffer = {}; VULKAN_HPP_NAMESPACE::DeviceSize offset = {}; + }; static_assert( sizeof( IndirectCommandsStreamNV ) == sizeof( VkIndirectCommandsStreamNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<IndirectCommandsStreamNV>::value, "struct wrapper is not a standard layout!" ); struct GeneratedCommandsInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsInfoNV; + VULKAN_HPP_CONSTEXPR GeneratedCommandsInfoNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics, VULKAN_HPP_NAMESPACE::Pipeline pipeline_ = {}, VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout_ = {}, @@ -37541,6 +40189,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkGeneratedCommandsInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkGeneratedCommandsInfoNV*>( this ); @@ -37551,6 +40200,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkGeneratedCommandsInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( GeneratedCommandsInfoNV const& ) const = default; #else @@ -37579,6 +40229,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGeneratedCommandsInfoNV; const void* pNext = {}; @@ -37595,12 +40247,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeviceSize sequencesCountOffset = {}; VULKAN_HPP_NAMESPACE::Buffer sequencesIndexBuffer = {}; VULKAN_HPP_NAMESPACE::DeviceSize sequencesIndexOffset = {}; + }; static_assert( sizeof( GeneratedCommandsInfoNV ) == sizeof( VkGeneratedCommandsInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<GeneratedCommandsInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eGeneratedCommandsInfoNV> + { + using Type = GeneratedCommandsInfoNV; + }; + struct GeneratedCommandsMemoryRequirementsInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsMemoryRequirementsInfoNV; + VULKAN_HPP_CONSTEXPR GeneratedCommandsMemoryRequirementsInfoNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics, VULKAN_HPP_NAMESPACE::Pipeline pipeline_ = {}, VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout_ = {}, @@ -37658,6 +40319,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkGeneratedCommandsMemoryRequirementsInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV*>( this ); @@ -37668,6 +40330,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkGeneratedCommandsMemoryRequirementsInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( GeneratedCommandsMemoryRequirementsInfoNV const& ) const = default; #else @@ -37687,6 +40350,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGeneratedCommandsMemoryRequirementsInfoNV; const void* pNext = {}; @@ -37694,12 +40359,20 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Pipeline pipeline = {}; VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout = {}; uint32_t maxSequencesCount = {}; + }; static_assert( sizeof( GeneratedCommandsMemoryRequirementsInfoNV ) == sizeof( VkGeneratedCommandsMemoryRequirementsInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<GeneratedCommandsMemoryRequirementsInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eGeneratedCommandsMemoryRequirementsInfoNV> + { + using Type = GeneratedCommandsMemoryRequirementsInfoNV; + }; + struct VertexInputBindingDescription { + VULKAN_HPP_CONSTEXPR VertexInputBindingDescription( uint32_t binding_ = {}, uint32_t stride_ = {}, VULKAN_HPP_NAMESPACE::VertexInputRate inputRate_ = VULKAN_HPP_NAMESPACE::VertexInputRate::eVertex ) VULKAN_HPP_NOEXCEPT @@ -37737,6 +40410,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkVertexInputBindingDescription const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkVertexInputBindingDescription*>( this ); @@ -37747,6 +40421,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkVertexInputBindingDescription*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( VertexInputBindingDescription const& ) const = default; #else @@ -37763,16 +40438,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t binding = {}; uint32_t stride = {}; VULKAN_HPP_NAMESPACE::VertexInputRate inputRate = VULKAN_HPP_NAMESPACE::VertexInputRate::eVertex; + }; static_assert( sizeof( VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<VertexInputBindingDescription>::value, "struct wrapper is not a standard layout!" ); struct VertexInputAttributeDescription { + VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription( uint32_t location_ = {}, uint32_t binding_ = {}, VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, @@ -37818,6 +40497,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkVertexInputAttributeDescription const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkVertexInputAttributeDescription*>( this ); @@ -37828,6 +40508,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkVertexInputAttributeDescription*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( VertexInputAttributeDescription const& ) const = default; #else @@ -37845,17 +40526,22 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t location = {}; uint32_t binding = {}; VULKAN_HPP_NAMESPACE::Format format = VULKAN_HPP_NAMESPACE::Format::eUndefined; uint32_t offset = {}; + }; static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<VertexInputAttributeDescription>::value, "struct wrapper is not a standard layout!" ); struct PipelineVertexInputStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineVertexInputStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags flags_ = {}, uint32_t vertexBindingDescriptionCount_ = {}, const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription* pVertexBindingDescriptions_ = {}, @@ -37921,6 +40607,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineVertexInputStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>( this ); @@ -37931,6 +40618,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineVertexInputStateCreateInfo const& ) const = default; #else @@ -37951,6 +40639,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo; const void* pNext = {}; @@ -37959,12 +40649,21 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription* pVertexBindingDescriptions = {}; uint32_t vertexAttributeDescriptionCount = {}; const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription* pVertexAttributeDescriptions = {}; + }; static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineVertexInputStateCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineVertexInputStateCreateInfo> + { + using Type = PipelineVertexInputStateCreateInfo; + }; + struct PipelineInputAssemblyStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineInputAssemblyStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::PrimitiveTopology topology_ = VULKAN_HPP_NAMESPACE::PrimitiveTopology::ePointList, VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable_ = {} ) VULKAN_HPP_NOEXCEPT @@ -38014,6 +40713,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineInputAssemblyStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>( this ); @@ -38024,6 +40724,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineInputAssemblyStateCreateInfo const& ) const = default; #else @@ -38042,18 +40743,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags flags = {}; VULKAN_HPP_NAMESPACE::PrimitiveTopology topology = VULKAN_HPP_NAMESPACE::PrimitiveTopology::ePointList; VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable = {}; + }; static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineInputAssemblyStateCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineInputAssemblyStateCreateInfo> + { + using Type = PipelineInputAssemblyStateCreateInfo; + }; + struct PipelineTessellationStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineTessellationStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags flags_ = {}, uint32_t patchControlPoints_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -38095,6 +40807,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineTessellationStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>( this ); @@ -38105,6 +40818,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineTessellationStateCreateInfo const& ) const = default; #else @@ -38122,17 +40836,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineTessellationStateCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags flags = {}; uint32_t patchControlPoints = {}; + }; static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineTessellationStateCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineTessellationStateCreateInfo> + { + using Type = PipelineTessellationStateCreateInfo; + }; + struct Viewport { + VULKAN_HPP_CONSTEXPR Viewport( float x_ = {}, float y_ = {}, float width_ = {}, @@ -38194,6 +40918,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkViewport const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkViewport*>( this ); @@ -38204,6 +40929,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkViewport*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( Viewport const& ) const = default; #else @@ -38223,6 +40949,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: float x = {}; float y = {}; @@ -38230,12 +40958,15 @@ namespace VULKAN_HPP_NAMESPACE float height = {}; float minDepth = {}; float maxDepth = {}; + }; static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<Viewport>::value, "struct wrapper is not a standard layout!" ); struct PipelineViewportStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags flags_ = {}, uint32_t viewportCount_ = {}, const VULKAN_HPP_NAMESPACE::Viewport* pViewports_ = {}, @@ -38301,6 +41032,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineViewportStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineViewportStateCreateInfo*>( this ); @@ -38311,6 +41043,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineViewportStateCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineViewportStateCreateInfo const& ) const = default; #else @@ -38331,6 +41064,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineViewportStateCreateInfo; const void* pNext = {}; @@ -38339,12 +41074,21 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::Viewport* pViewports = {}; uint32_t scissorCount = {}; const VULKAN_HPP_NAMESPACE::Rect2D* pScissors = {}; + }; static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineViewportStateCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineViewportStateCreateInfo> + { + using Type = PipelineViewportStateCreateInfo; + }; + struct PipelineRasterizationStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable_ = {}, VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable_ = {}, @@ -38458,6 +41202,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineRasterizationStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>( this ); @@ -38468,6 +41213,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineRasterizationStateCreateInfo const& ) const = default; #else @@ -38494,6 +41240,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo; const void* pNext = {}; @@ -38508,12 +41256,21 @@ namespace VULKAN_HPP_NAMESPACE float depthBiasClamp = {}; float depthBiasSlopeFactor = {}; float lineWidth = {}; + }; static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineRasterizationStateCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineRasterizationStateCreateInfo> + { + using Type = PipelineRasterizationStateCreateInfo; + }; + struct PipelineMultisampleStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineMultisampleStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1, VULKAN_HPP_NAMESPACE::Bool32 sampleShadingEnable_ = {}, @@ -38595,6 +41352,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineMultisampleStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>( this ); @@ -38605,6 +41363,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineMultisampleStateCreateInfo const& ) const = default; #else @@ -38627,6 +41386,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo; const void* pNext = {}; @@ -38637,12 +41398,20 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::SampleMask* pSampleMask = {}; VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable = {}; VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable = {}; + }; static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineMultisampleStateCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineMultisampleStateCreateInfo> + { + using Type = PipelineMultisampleStateCreateInfo; + }; + struct StencilOpState { + VULKAN_HPP_CONSTEXPR StencilOpState( VULKAN_HPP_NAMESPACE::StencilOp failOp_ = VULKAN_HPP_NAMESPACE::StencilOp::eKeep, VULKAN_HPP_NAMESPACE::StencilOp passOp_ = VULKAN_HPP_NAMESPACE::StencilOp::eKeep, VULKAN_HPP_NAMESPACE::StencilOp depthFailOp_ = VULKAN_HPP_NAMESPACE::StencilOp::eKeep, @@ -38712,6 +41481,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkStencilOpState const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkStencilOpState*>( this ); @@ -38722,6 +41492,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkStencilOpState*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( StencilOpState const& ) const = default; #else @@ -38742,6 +41513,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::StencilOp failOp = VULKAN_HPP_NAMESPACE::StencilOp::eKeep; VULKAN_HPP_NAMESPACE::StencilOp passOp = VULKAN_HPP_NAMESPACE::StencilOp::eKeep; @@ -38750,12 +41523,15 @@ namespace VULKAN_HPP_NAMESPACE uint32_t compareMask = {}; uint32_t writeMask = {}; uint32_t reference = {}; + }; static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<StencilOpState>::value, "struct wrapper is not a standard layout!" ); struct PipelineDepthStencilStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineDepthStencilStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable_ = {}, VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable_ = {}, @@ -38837,13 +41613,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - PipelineDepthStencilStateCreateInfo & setFront( VULKAN_HPP_NAMESPACE::StencilOpState front_ ) VULKAN_HPP_NOEXCEPT + PipelineDepthStencilStateCreateInfo & setFront( VULKAN_HPP_NAMESPACE::StencilOpState const & front_ ) VULKAN_HPP_NOEXCEPT { front = front_; return *this; } - PipelineDepthStencilStateCreateInfo & setBack( VULKAN_HPP_NAMESPACE::StencilOpState back_ ) VULKAN_HPP_NOEXCEPT + PipelineDepthStencilStateCreateInfo & setBack( VULKAN_HPP_NAMESPACE::StencilOpState const & back_ ) VULKAN_HPP_NOEXCEPT { back = back_; return *this; @@ -38861,6 +41637,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineDepthStencilStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>( this ); @@ -38871,6 +41648,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineDepthStencilStateCreateInfo const& ) const = default; #else @@ -38896,6 +41674,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo; const void* pNext = {}; @@ -38909,12 +41689,20 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::StencilOpState back = {}; float minDepthBounds = {}; float maxDepthBounds = {}; + }; static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineDepthStencilStateCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineDepthStencilStateCreateInfo> + { + using Type = PipelineDepthStencilStateCreateInfo; + }; + struct PipelineColorBlendAttachmentState { + VULKAN_HPP_CONSTEXPR PipelineColorBlendAttachmentState( VULKAN_HPP_NAMESPACE::Bool32 blendEnable_ = {}, VULKAN_HPP_NAMESPACE::BlendFactor srcColorBlendFactor_ = VULKAN_HPP_NAMESPACE::BlendFactor::eZero, VULKAN_HPP_NAMESPACE::BlendFactor dstColorBlendFactor_ = VULKAN_HPP_NAMESPACE::BlendFactor::eZero, @@ -38992,6 +41780,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineColorBlendAttachmentState const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineColorBlendAttachmentState*>( this ); @@ -39002,6 +41791,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineColorBlendAttachmentState*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineColorBlendAttachmentState const& ) const = default; #else @@ -39023,6 +41813,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Bool32 blendEnable = {}; VULKAN_HPP_NAMESPACE::BlendFactor srcColorBlendFactor = VULKAN_HPP_NAMESPACE::BlendFactor::eZero; @@ -39032,12 +41824,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::BlendFactor dstAlphaBlendFactor = VULKAN_HPP_NAMESPACE::BlendFactor::eZero; VULKAN_HPP_NAMESPACE::BlendOp alphaBlendOp = VULKAN_HPP_NAMESPACE::BlendOp::eAdd; VULKAN_HPP_NAMESPACE::ColorComponentFlags colorWriteMask = {}; + }; static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineColorBlendAttachmentState>::value, "struct wrapper is not a standard layout!" ); struct PipelineColorBlendStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineColorBlendStateCreateInfo; + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable_ = {}, VULKAN_HPP_NAMESPACE::LogicOp logicOp_ = VULKAN_HPP_NAMESPACE::LogicOp::eClear, @@ -39111,6 +41906,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineColorBlendStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>( this ); @@ -39121,6 +41917,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineColorBlendStateCreateInfo const& ) const = default; #else @@ -39142,6 +41939,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo; const void* pNext = {}; @@ -39151,12 +41950,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t attachmentCount = {}; const VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState* pAttachments = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> blendConstants = {}; + }; static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineColorBlendStateCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineColorBlendStateCreateInfo> + { + using Type = PipelineColorBlendStateCreateInfo; + }; + struct PipelineDynamicStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineDynamicStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags flags_ = {}, uint32_t dynamicStateCount_ = {}, const VULKAN_HPP_NAMESPACE::DynamicState* pDynamicStates_ = {} ) VULKAN_HPP_NOEXCEPT @@ -39206,6 +42014,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineDynamicStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>( this ); @@ -39216,6 +42025,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineDynamicStateCreateInfo const& ) const = default; #else @@ -39234,18 +42044,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineDynamicStateCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags flags = {}; uint32_t dynamicStateCount = {}; const VULKAN_HPP_NAMESPACE::DynamicState* pDynamicStates = {}; + }; static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineDynamicStateCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineDynamicStateCreateInfo> + { + using Type = PipelineDynamicStateCreateInfo; + }; + struct GraphicsPipelineCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsPipelineCreateInfo; + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo( VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags_ = {}, uint32_t stageCount_ = {}, const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo* pStages_ = {}, @@ -39407,6 +42228,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkGraphicsPipelineCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( this ); @@ -39417,6 +42239,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkGraphicsPipelineCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( GraphicsPipelineCreateInfo const& ) const = default; #else @@ -39449,6 +42272,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGraphicsPipelineCreateInfo; const void* pNext = {}; @@ -39469,12 +42294,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t subpass = {}; VULKAN_HPP_NAMESPACE::Pipeline basePipelineHandle = {}; int32_t basePipelineIndex = {}; + }; static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<GraphicsPipelineCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eGraphicsPipelineCreateInfo> + { + using Type = GraphicsPipelineCreateInfo; + }; + struct GraphicsShaderGroupCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsShaderGroupCreateInfoNV; + VULKAN_HPP_CONSTEXPR GraphicsShaderGroupCreateInfoNV( uint32_t stageCount_ = {}, const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo* pStages_ = {}, const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo* pVertexInputState_ = {}, @@ -39532,6 +42366,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkGraphicsShaderGroupCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkGraphicsShaderGroupCreateInfoNV*>( this ); @@ -39542,6 +42377,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkGraphicsShaderGroupCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( GraphicsShaderGroupCreateInfoNV const& ) const = default; #else @@ -39561,6 +42397,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGraphicsShaderGroupCreateInfoNV; const void* pNext = {}; @@ -39568,12 +42406,21 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo* pStages = {}; const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo* pVertexInputState = {}; const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo* pTessellationState = {}; + }; static_assert( sizeof( GraphicsShaderGroupCreateInfoNV ) == sizeof( VkGraphicsShaderGroupCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<GraphicsShaderGroupCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eGraphicsShaderGroupCreateInfoNV> + { + using Type = GraphicsShaderGroupCreateInfoNV; + }; + struct GraphicsPipelineShaderGroupsCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV; + VULKAN_HPP_CONSTEXPR GraphicsPipelineShaderGroupsCreateInfoNV( uint32_t groupCount_ = {}, const VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV* pGroups_ = {}, uint32_t pipelineCount_ = {}, @@ -39631,6 +42478,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkGraphicsPipelineShaderGroupsCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>( this ); @@ -39641,6 +42489,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( GraphicsPipelineShaderGroupsCreateInfoNV const& ) const = default; #else @@ -39660,6 +42509,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV; const void* pNext = {}; @@ -39667,12 +42518,20 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV* pGroups = {}; uint32_t pipelineCount = {}; const VULKAN_HPP_NAMESPACE::Pipeline* pPipelines = {}; + }; static_assert( sizeof( GraphicsPipelineShaderGroupsCreateInfoNV ) == sizeof( VkGraphicsPipelineShaderGroupsCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<GraphicsPipelineShaderGroupsCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV> + { + using Type = GraphicsPipelineShaderGroupsCreateInfoNV; + }; + struct XYColorEXT { + VULKAN_HPP_CONSTEXPR XYColorEXT( float x_ = {}, float y_ = {} ) VULKAN_HPP_NOEXCEPT : x( x_ ) @@ -39702,6 +42561,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkXYColorEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkXYColorEXT*>( this ); @@ -39712,6 +42572,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkXYColorEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( XYColorEXT const& ) const = default; #else @@ -39727,15 +42588,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: float x = {}; float y = {}; + }; static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<XYColorEXT>::value, "struct wrapper is not a standard layout!" ); struct HdrMetadataEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHdrMetadataEXT; + VULKAN_HPP_CONSTEXPR HdrMetadataEXT( VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryRed_ = {}, VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryGreen_ = {}, VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryBlue_ = {}, @@ -39777,25 +42643,25 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - HdrMetadataEXT & setDisplayPrimaryRed( VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryRed_ ) VULKAN_HPP_NOEXCEPT + HdrMetadataEXT & setDisplayPrimaryRed( VULKAN_HPP_NAMESPACE::XYColorEXT const & displayPrimaryRed_ ) VULKAN_HPP_NOEXCEPT { displayPrimaryRed = displayPrimaryRed_; return *this; } - HdrMetadataEXT & setDisplayPrimaryGreen( VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryGreen_ ) VULKAN_HPP_NOEXCEPT + HdrMetadataEXT & setDisplayPrimaryGreen( VULKAN_HPP_NAMESPACE::XYColorEXT const & displayPrimaryGreen_ ) VULKAN_HPP_NOEXCEPT { displayPrimaryGreen = displayPrimaryGreen_; return *this; } - HdrMetadataEXT & setDisplayPrimaryBlue( VULKAN_HPP_NAMESPACE::XYColorEXT displayPrimaryBlue_ ) VULKAN_HPP_NOEXCEPT + HdrMetadataEXT & setDisplayPrimaryBlue( VULKAN_HPP_NAMESPACE::XYColorEXT const & displayPrimaryBlue_ ) VULKAN_HPP_NOEXCEPT { displayPrimaryBlue = displayPrimaryBlue_; return *this; } - HdrMetadataEXT & setWhitePoint( VULKAN_HPP_NAMESPACE::XYColorEXT whitePoint_ ) VULKAN_HPP_NOEXCEPT + HdrMetadataEXT & setWhitePoint( VULKAN_HPP_NAMESPACE::XYColorEXT const & whitePoint_ ) VULKAN_HPP_NOEXCEPT { whitePoint = whitePoint_; return *this; @@ -39825,6 +42691,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkHdrMetadataEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkHdrMetadataEXT*>( this ); @@ -39835,6 +42702,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkHdrMetadataEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( HdrMetadataEXT const& ) const = default; #else @@ -39858,6 +42726,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eHdrMetadataEXT; const void* pNext = {}; @@ -39869,12 +42739,21 @@ namespace VULKAN_HPP_NAMESPACE float minLuminance = {}; float maxContentLightLevel = {}; float maxFrameAverageLightLevel = {}; + }; static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<HdrMetadataEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eHdrMetadataEXT> + { + using Type = HdrMetadataEXT; + }; + struct HeadlessSurfaceCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHeadlessSurfaceCreateInfoEXT; + VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT flags_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) {} @@ -39908,6 +42787,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkHeadlessSurfaceCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT*>( this ); @@ -39918,6 +42798,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( HeadlessSurfaceCreateInfoEXT const& ) const = default; #else @@ -39934,17 +42815,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eHeadlessSurfaceCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT flags = {}; + }; static_assert( sizeof( HeadlessSurfaceCreateInfoEXT ) == sizeof( VkHeadlessSurfaceCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<HeadlessSurfaceCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eHeadlessSurfaceCreateInfoEXT> + { + using Type = HeadlessSurfaceCreateInfoEXT; + }; + #ifdef VK_USE_PLATFORM_IOS_MVK struct IOSSurfaceCreateInfoMVK { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIosSurfaceCreateInfoMVK; + VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK flags_ = {}, const void* pView_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -39986,6 +42878,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkIOSSurfaceCreateInfoMVK const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( this ); @@ -39996,6 +42889,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkIOSSurfaceCreateInfoMVK*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( IOSSurfaceCreateInfoMVK const& ) const = default; #else @@ -40013,18 +42907,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eIosSurfaceCreateInfoMVK; const void* pNext = {}; VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK flags = {}; const void* pView = {}; + }; static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<IOSSurfaceCreateInfoMVK>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eIosSurfaceCreateInfoMVK> + { + using Type = IOSSurfaceCreateInfoMVK; + }; #endif /*VK_USE_PLATFORM_IOS_MVK*/ struct ImageBlit { + VULKAN_HPP_CONSTEXPR_14 ImageBlit( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource_ = {}, std::array<VULKAN_HPP_NAMESPACE::Offset3D,2> const& srcOffsets_ = {}, VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource_ = {}, @@ -40046,30 +42950,31 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - ImageBlit & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource_ ) VULKAN_HPP_NOEXCEPT + ImageBlit & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & srcSubresource_ ) VULKAN_HPP_NOEXCEPT { srcSubresource = srcSubresource_; return *this; } - ImageBlit & setSrcOffsets( std::array<VULKAN_HPP_NAMESPACE::Offset3D,2> srcOffsets_ ) VULKAN_HPP_NOEXCEPT + ImageBlit & setSrcOffsets( std::array<VULKAN_HPP_NAMESPACE::Offset3D,2> const & srcOffsets_ ) VULKAN_HPP_NOEXCEPT { srcOffsets = srcOffsets_; return *this; } - ImageBlit & setDstSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource_ ) VULKAN_HPP_NOEXCEPT + ImageBlit & setDstSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & dstSubresource_ ) VULKAN_HPP_NOEXCEPT { dstSubresource = dstSubresource_; return *this; } - ImageBlit & setDstOffsets( std::array<VULKAN_HPP_NAMESPACE::Offset3D,2> dstOffsets_ ) VULKAN_HPP_NOEXCEPT + ImageBlit & setDstOffsets( std::array<VULKAN_HPP_NAMESPACE::Offset3D,2> const & dstOffsets_ ) VULKAN_HPP_NOEXCEPT { dstOffsets = dstOffsets_; return *this; } + operator VkImageBlit const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageBlit*>( this ); @@ -40080,6 +42985,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageBlit*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageBlit const& ) const = default; #else @@ -40097,17 +43003,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> srcOffsets = {}; VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> dstOffsets = {}; + }; static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageBlit>::value, "struct wrapper is not a standard layout!" ); struct ImageCopy { + VULKAN_HPP_CONSTEXPR ImageCopy( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource_ = {}, VULKAN_HPP_NAMESPACE::Offset3D srcOffset_ = {}, VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource_ = {}, @@ -40131,36 +43041,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - ImageCopy & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource_ ) VULKAN_HPP_NOEXCEPT + ImageCopy & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & srcSubresource_ ) VULKAN_HPP_NOEXCEPT { srcSubresource = srcSubresource_; return *this; } - ImageCopy & setSrcOffset( VULKAN_HPP_NAMESPACE::Offset3D srcOffset_ ) VULKAN_HPP_NOEXCEPT + ImageCopy & setSrcOffset( VULKAN_HPP_NAMESPACE::Offset3D const & srcOffset_ ) VULKAN_HPP_NOEXCEPT { srcOffset = srcOffset_; return *this; } - ImageCopy & setDstSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource_ ) VULKAN_HPP_NOEXCEPT + ImageCopy & setDstSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & dstSubresource_ ) VULKAN_HPP_NOEXCEPT { dstSubresource = dstSubresource_; return *this; } - ImageCopy & setDstOffset( VULKAN_HPP_NAMESPACE::Offset3D dstOffset_ ) VULKAN_HPP_NOEXCEPT + ImageCopy & setDstOffset( VULKAN_HPP_NAMESPACE::Offset3D const & dstOffset_ ) VULKAN_HPP_NOEXCEPT { dstOffset = dstOffset_; return *this; } - ImageCopy & setExtent( VULKAN_HPP_NAMESPACE::Extent3D extent_ ) VULKAN_HPP_NOEXCEPT + ImageCopy & setExtent( VULKAN_HPP_NAMESPACE::Extent3D const & extent_ ) VULKAN_HPP_NOEXCEPT { extent = extent_; return *this; } + operator VkImageCopy const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageCopy*>( this ); @@ -40171,6 +43082,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageCopy*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageCopy const& ) const = default; #else @@ -40189,18 +43101,23 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource = {}; VULKAN_HPP_NAMESPACE::Offset3D srcOffset = {}; VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource = {}; VULKAN_HPP_NAMESPACE::Offset3D dstOffset = {}; VULKAN_HPP_NAMESPACE::Extent3D extent = {}; + }; static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageCopy>::value, "struct wrapper is not a standard layout!" ); struct ImageCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageCreateInfo; + VULKAN_HPP_CONSTEXPR ImageCreateInfo( VULKAN_HPP_NAMESPACE::ImageCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::ImageType imageType_ = VULKAN_HPP_NAMESPACE::ImageType::e1D, VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, @@ -40270,7 +43187,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - ImageCreateInfo & setExtent( VULKAN_HPP_NAMESPACE::Extent3D extent_ ) VULKAN_HPP_NOEXCEPT + ImageCreateInfo & setExtent( VULKAN_HPP_NAMESPACE::Extent3D const & extent_ ) VULKAN_HPP_NOEXCEPT { extent = extent_; return *this; @@ -40330,6 +43247,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageCreateInfo*>( this ); @@ -40340,6 +43258,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageCreateInfo const& ) const = default; #else @@ -40368,6 +43287,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageCreateInfo; const void* pNext = {}; @@ -40384,12 +43305,20 @@ namespace VULKAN_HPP_NAMESPACE uint32_t queueFamilyIndexCount = {}; const uint32_t* pQueueFamilyIndices = {}; VULKAN_HPP_NAMESPACE::ImageLayout initialLayout = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined; + }; static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageCreateInfo> + { + using Type = ImageCreateInfo; + }; + struct SubresourceLayout { + VULKAN_HPP_CONSTEXPR SubresourceLayout( VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize size_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize rowPitch_ = {}, @@ -40413,6 +43342,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSubresourceLayout const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSubresourceLayout*>( this ); @@ -40423,6 +43353,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSubresourceLayout*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SubresourceLayout const& ) const = default; #else @@ -40441,18 +43372,23 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::DeviceSize offset = {}; VULKAN_HPP_NAMESPACE::DeviceSize size = {}; VULKAN_HPP_NAMESPACE::DeviceSize rowPitch = {}; VULKAN_HPP_NAMESPACE::DeviceSize arrayPitch = {}; VULKAN_HPP_NAMESPACE::DeviceSize depthPitch = {}; + }; static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SubresourceLayout>::value, "struct wrapper is not a standard layout!" ); struct ImageDrmFormatModifierExplicitCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT; + VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = {}, uint32_t drmFormatModifierPlaneCount_ = {}, const VULKAN_HPP_NAMESPACE::SubresourceLayout* pPlaneLayouts_ = {} ) VULKAN_HPP_NOEXCEPT @@ -40502,6 +43438,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageDrmFormatModifierExplicitCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>( this ); @@ -40512,6 +43449,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageDrmFormatModifierExplicitCreateInfoEXT const& ) const = default; #else @@ -40530,18 +43468,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT; const void* pNext = {}; uint64_t drmFormatModifier = {}; uint32_t drmFormatModifierPlaneCount = {}; const VULKAN_HPP_NAMESPACE::SubresourceLayout* pPlaneLayouts = {}; + }; static_assert( sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageDrmFormatModifierExplicitCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT> + { + using Type = ImageDrmFormatModifierExplicitCreateInfoEXT; + }; + struct ImageDrmFormatModifierListCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageDrmFormatModifierListCreateInfoEXT; + VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = {}, const uint64_t* pDrmFormatModifiers_ = {} ) VULKAN_HPP_NOEXCEPT : drmFormatModifierCount( drmFormatModifierCount_ ) @@ -40583,6 +43532,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageDrmFormatModifierListCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>( this ); @@ -40593,6 +43543,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageDrmFormatModifierListCreateInfoEXT const& ) const = default; #else @@ -40610,17 +43561,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT; const void* pNext = {}; uint32_t drmFormatModifierCount = {}; const uint64_t* pDrmFormatModifiers = {}; + }; static_assert( sizeof( ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageDrmFormatModifierListCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageDrmFormatModifierListCreateInfoEXT> + { + using Type = ImageDrmFormatModifierListCreateInfoEXT; + }; + struct ImageDrmFormatModifierPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageDrmFormatModifierPropertiesEXT; + VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = {} ) VULKAN_HPP_NOEXCEPT : drmFormatModifier( drmFormatModifier_ ) {} @@ -40642,6 +43604,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageDrmFormatModifierPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageDrmFormatModifierPropertiesEXT*>( this ); @@ -40652,6 +43615,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageDrmFormatModifierPropertiesEXT const& ) const = default; #else @@ -40668,16 +43632,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT; void* pNext = {}; uint64_t drmFormatModifier = {}; + }; static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageDrmFormatModifierPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageDrmFormatModifierPropertiesEXT> + { + using Type = ImageDrmFormatModifierPropertiesEXT; + }; + struct ImageFormatListCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageFormatListCreateInfo; + VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfo( uint32_t viewFormatCount_ = {}, const VULKAN_HPP_NAMESPACE::Format* pViewFormats_ = {} ) VULKAN_HPP_NOEXCEPT : viewFormatCount( viewFormatCount_ ) @@ -40719,6 +43694,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageFormatListCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageFormatListCreateInfo*>( this ); @@ -40729,6 +43705,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageFormatListCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageFormatListCreateInfo const& ) const = default; #else @@ -40746,17 +43723,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageFormatListCreateInfo; const void* pNext = {}; uint32_t viewFormatCount = {}; const VULKAN_HPP_NAMESPACE::Format* pViewFormats = {}; + }; static_assert( sizeof( ImageFormatListCreateInfo ) == sizeof( VkImageFormatListCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageFormatListCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageFormatListCreateInfo> + { + using Type = ImageFormatListCreateInfo; + }; + struct ImageFormatProperties2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageFormatProperties2; + VULKAN_HPP_CONSTEXPR ImageFormatProperties2( VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties_ = {} ) VULKAN_HPP_NOEXCEPT : imageFormatProperties( imageFormatProperties_ ) {} @@ -40778,6 +43766,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageFormatProperties2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageFormatProperties2*>( this ); @@ -40788,6 +43777,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageFormatProperties2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageFormatProperties2 const& ) const = default; #else @@ -40804,16 +43794,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageFormatProperties2; void* pNext = {}; VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties = {}; + }; static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageFormatProperties2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageFormatProperties2> + { + using Type = ImageFormatProperties2; + }; + struct ImageSubresourceRange { + VULKAN_HPP_CONSTEXPR ImageSubresourceRange( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {}, uint32_t baseMipLevel_ = {}, uint32_t levelCount_ = {}, @@ -40867,6 +43867,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageSubresourceRange const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageSubresourceRange*>( this ); @@ -40877,6 +43878,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageSubresourceRange*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageSubresourceRange const& ) const = default; #else @@ -40895,18 +43897,23 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {}; uint32_t baseMipLevel = {}; uint32_t levelCount = {}; uint32_t baseArrayLayer = {}; uint32_t layerCount = {}; + }; static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageSubresourceRange>::value, "struct wrapper is not a standard layout!" ); struct ImageMemoryBarrier { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageMemoryBarrier; + VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask_ = {}, VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask_ = {}, VULKAN_HPP_NAMESPACE::ImageLayout oldLayout_ = VULKAN_HPP_NAMESPACE::ImageLayout::eUndefined, @@ -40990,12 +43997,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - ImageMemoryBarrier & setSubresourceRange( VULKAN_HPP_NAMESPACE::ImageSubresourceRange subresourceRange_ ) VULKAN_HPP_NOEXCEPT + ImageMemoryBarrier & setSubresourceRange( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & subresourceRange_ ) VULKAN_HPP_NOEXCEPT { subresourceRange = subresourceRange_; return *this; } + operator VkImageMemoryBarrier const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageMemoryBarrier*>( this ); @@ -41006,6 +44014,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageMemoryBarrier*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageMemoryBarrier const& ) const = default; #else @@ -41029,6 +44038,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageMemoryBarrier; const void* pNext = {}; @@ -41040,12 +44051,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t dstQueueFamilyIndex = {}; VULKAN_HPP_NAMESPACE::Image image = {}; VULKAN_HPP_NAMESPACE::ImageSubresourceRange subresourceRange = {}; + }; static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageMemoryBarrier>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageMemoryBarrier> + { + using Type = ImageMemoryBarrier; + }; + struct ImageMemoryRequirementsInfo2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageMemoryRequirementsInfo2; + VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( VULKAN_HPP_NAMESPACE::Image image_ = {} ) VULKAN_HPP_NOEXCEPT : image( image_ ) {} @@ -41079,6 +44099,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageMemoryRequirementsInfo2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( this ); @@ -41089,6 +44110,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageMemoryRequirementsInfo2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageMemoryRequirementsInfo2 const& ) const = default; #else @@ -41105,17 +44127,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageMemoryRequirementsInfo2; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Image image = {}; + }; static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageMemoryRequirementsInfo2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageMemoryRequirementsInfo2> + { + using Type = ImageMemoryRequirementsInfo2; + }; + #ifdef VK_USE_PLATFORM_FUCHSIA struct ImagePipeSurfaceCreateInfoFUCHSIA { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA; + VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = {}, zx_handle_t imagePipeHandle_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -41157,6 +44190,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImagePipeSurfaceCreateInfoFUCHSIA const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( this ); @@ -41167,6 +44201,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImagePipeSurfaceCreateInfoFUCHSIA const& ) const = default; #else @@ -41184,18 +44219,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA flags = {}; zx_handle_t imagePipeHandle = {}; + }; static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImagePipeSurfaceCreateInfoFUCHSIA>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eImagepipeSurfaceCreateInfoFUCHSIA> + { + using Type = ImagePipeSurfaceCreateInfoFUCHSIA; + }; #endif /*VK_USE_PLATFORM_FUCHSIA*/ struct ImagePlaneMemoryRequirementsInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImagePlaneMemoryRequirementsInfo; + VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( VULKAN_HPP_NAMESPACE::ImageAspectFlagBits planeAspect_ = VULKAN_HPP_NAMESPACE::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT : planeAspect( planeAspect_ ) {} @@ -41229,6 +44275,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImagePlaneMemoryRequirementsInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>( this ); @@ -41239,6 +44286,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImagePlaneMemoryRequirementsInfo const& ) const = default; #else @@ -41255,16 +44303,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ImageAspectFlagBits planeAspect = VULKAN_HPP_NAMESPACE::ImageAspectFlagBits::eColor; + }; static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImagePlaneMemoryRequirementsInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImagePlaneMemoryRequirementsInfo> + { + using Type = ImagePlaneMemoryRequirementsInfo; + }; + struct ImageResolve { + VULKAN_HPP_CONSTEXPR ImageResolve( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource_ = {}, VULKAN_HPP_NAMESPACE::Offset3D srcOffset_ = {}, VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource_ = {}, @@ -41288,36 +44346,37 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - ImageResolve & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource_ ) VULKAN_HPP_NOEXCEPT + ImageResolve & setSrcSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & srcSubresource_ ) VULKAN_HPP_NOEXCEPT { srcSubresource = srcSubresource_; return *this; } - ImageResolve & setSrcOffset( VULKAN_HPP_NAMESPACE::Offset3D srcOffset_ ) VULKAN_HPP_NOEXCEPT + ImageResolve & setSrcOffset( VULKAN_HPP_NAMESPACE::Offset3D const & srcOffset_ ) VULKAN_HPP_NOEXCEPT { srcOffset = srcOffset_; return *this; } - ImageResolve & setDstSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource_ ) VULKAN_HPP_NOEXCEPT + ImageResolve & setDstSubresource( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & dstSubresource_ ) VULKAN_HPP_NOEXCEPT { dstSubresource = dstSubresource_; return *this; } - ImageResolve & setDstOffset( VULKAN_HPP_NAMESPACE::Offset3D dstOffset_ ) VULKAN_HPP_NOEXCEPT + ImageResolve & setDstOffset( VULKAN_HPP_NAMESPACE::Offset3D const & dstOffset_ ) VULKAN_HPP_NOEXCEPT { dstOffset = dstOffset_; return *this; } - ImageResolve & setExtent( VULKAN_HPP_NAMESPACE::Extent3D extent_ ) VULKAN_HPP_NOEXCEPT + ImageResolve & setExtent( VULKAN_HPP_NAMESPACE::Extent3D const & extent_ ) VULKAN_HPP_NOEXCEPT { extent = extent_; return *this; } + operator VkImageResolve const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageResolve*>( this ); @@ -41328,6 +44387,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageResolve*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageResolve const& ) const = default; #else @@ -41346,18 +44406,23 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ImageSubresourceLayers srcSubresource = {}; VULKAN_HPP_NAMESPACE::Offset3D srcOffset = {}; VULKAN_HPP_NAMESPACE::ImageSubresourceLayers dstSubresource = {}; VULKAN_HPP_NAMESPACE::Offset3D dstOffset = {}; VULKAN_HPP_NAMESPACE::Extent3D extent = {}; + }; static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageResolve>::value, "struct wrapper is not a standard layout!" ); struct ImageSparseMemoryRequirementsInfo2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageSparseMemoryRequirementsInfo2; + VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( VULKAN_HPP_NAMESPACE::Image image_ = {} ) VULKAN_HPP_NOEXCEPT : image( image_ ) {} @@ -41391,6 +44456,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageSparseMemoryRequirementsInfo2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( this ); @@ -41401,6 +44467,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageSparseMemoryRequirementsInfo2 const& ) const = default; #else @@ -41417,16 +44484,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Image image = {}; + }; static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageSparseMemoryRequirementsInfo2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageSparseMemoryRequirementsInfo2> + { + using Type = ImageSparseMemoryRequirementsInfo2; + }; + struct ImageStencilUsageCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageStencilUsageCreateInfo; + VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfo( VULKAN_HPP_NAMESPACE::ImageUsageFlags stencilUsage_ = {} ) VULKAN_HPP_NOEXCEPT : stencilUsage( stencilUsage_ ) {} @@ -41460,6 +44538,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageStencilUsageCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageStencilUsageCreateInfo*>( this ); @@ -41470,6 +44549,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageStencilUsageCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageStencilUsageCreateInfo const& ) const = default; #else @@ -41486,16 +44566,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageStencilUsageCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ImageUsageFlags stencilUsage = {}; + }; static_assert( sizeof( ImageStencilUsageCreateInfo ) == sizeof( VkImageStencilUsageCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageStencilUsageCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageStencilUsageCreateInfo> + { + using Type = ImageStencilUsageCreateInfo; + }; + struct ImageSwapchainCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageSwapchainCreateInfoKHR; + VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain_ = {} ) VULKAN_HPP_NOEXCEPT : swapchain( swapchain_ ) {} @@ -41529,6 +44620,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageSwapchainCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>( this ); @@ -41539,6 +44631,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageSwapchainCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageSwapchainCreateInfoKHR const& ) const = default; #else @@ -41555,16 +44648,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageSwapchainCreateInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain = {}; + }; static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageSwapchainCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageSwapchainCreateInfoKHR> + { + using Type = ImageSwapchainCreateInfoKHR; + }; + struct ImageViewASTCDecodeModeEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewAstcDecodeModeEXT; + VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( VULKAN_HPP_NAMESPACE::Format decodeMode_ = VULKAN_HPP_NAMESPACE::Format::eUndefined ) VULKAN_HPP_NOEXCEPT : decodeMode( decodeMode_ ) {} @@ -41598,6 +44702,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageViewASTCDecodeModeEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>( this ); @@ -41608,6 +44713,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageViewASTCDecodeModeEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageViewASTCDecodeModeEXT const& ) const = default; #else @@ -41624,16 +44730,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageViewAstcDecodeModeEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Format decodeMode = VULKAN_HPP_NAMESPACE::Format::eUndefined; + }; static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageViewASTCDecodeModeEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageViewAstcDecodeModeEXT> + { + using Type = ImageViewASTCDecodeModeEXT; + }; + struct ImageViewAddressPropertiesNVX { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewAddressPropertiesNVX; + VULKAN_HPP_CONSTEXPR ImageViewAddressPropertiesNVX( VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT : deviceAddress( deviceAddress_ ) @@ -41657,6 +44774,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageViewAddressPropertiesNVX const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageViewAddressPropertiesNVX*>( this ); @@ -41667,6 +44785,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageViewAddressPropertiesNVX*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageViewAddressPropertiesNVX const& ) const = default; #else @@ -41684,17 +44803,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageViewAddressPropertiesNVX; void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress = {}; VULKAN_HPP_NAMESPACE::DeviceSize size = {}; + }; static_assert( sizeof( ImageViewAddressPropertiesNVX ) == sizeof( VkImageViewAddressPropertiesNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageViewAddressPropertiesNVX>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageViewAddressPropertiesNVX> + { + using Type = ImageViewAddressPropertiesNVX; + }; + struct ImageViewCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewCreateInfo; + VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( VULKAN_HPP_NAMESPACE::ImageViewCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Image image_ = {}, VULKAN_HPP_NAMESPACE::ImageViewType viewType_ = VULKAN_HPP_NAMESPACE::ImageViewType::e1D, @@ -41756,18 +44886,19 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - ImageViewCreateInfo & setComponents( VULKAN_HPP_NAMESPACE::ComponentMapping components_ ) VULKAN_HPP_NOEXCEPT + ImageViewCreateInfo & setComponents( VULKAN_HPP_NAMESPACE::ComponentMapping const & components_ ) VULKAN_HPP_NOEXCEPT { components = components_; return *this; } - ImageViewCreateInfo & setSubresourceRange( VULKAN_HPP_NAMESPACE::ImageSubresourceRange subresourceRange_ ) VULKAN_HPP_NOEXCEPT + ImageViewCreateInfo & setSubresourceRange( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & subresourceRange_ ) VULKAN_HPP_NOEXCEPT { subresourceRange = subresourceRange_; return *this; } + operator VkImageViewCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageViewCreateInfo*>( this ); @@ -41778,6 +44909,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageViewCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageViewCreateInfo const& ) const = default; #else @@ -41799,6 +44931,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageViewCreateInfo; const void* pNext = {}; @@ -41808,12 +44942,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Format format = VULKAN_HPP_NAMESPACE::Format::eUndefined; VULKAN_HPP_NAMESPACE::ComponentMapping components = {}; VULKAN_HPP_NAMESPACE::ImageSubresourceRange subresourceRange = {}; + }; static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageViewCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageViewCreateInfo> + { + using Type = ImageViewCreateInfo; + }; + struct ImageViewHandleInfoNVX { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewHandleInfoNVX; + VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( VULKAN_HPP_NAMESPACE::ImageView imageView_ = {}, VULKAN_HPP_NAMESPACE::DescriptorType descriptorType_ = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler, VULKAN_HPP_NAMESPACE::Sampler sampler_ = {} ) VULKAN_HPP_NOEXCEPT @@ -41863,6 +45006,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageViewHandleInfoNVX const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageViewHandleInfoNVX*>( this ); @@ -41873,6 +45017,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageViewHandleInfoNVX*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageViewHandleInfoNVX const& ) const = default; #else @@ -41891,18 +45036,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageViewHandleInfoNVX; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ImageView imageView = {}; VULKAN_HPP_NAMESPACE::DescriptorType descriptorType = VULKAN_HPP_NAMESPACE::DescriptorType::eSampler; VULKAN_HPP_NAMESPACE::Sampler sampler = {}; + }; static_assert( sizeof( ImageViewHandleInfoNVX ) == sizeof( VkImageViewHandleInfoNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageViewHandleInfoNVX>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageViewHandleInfoNVX> + { + using Type = ImageViewHandleInfoNVX; + }; + struct ImageViewUsageCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewUsageCreateInfo; + VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( VULKAN_HPP_NAMESPACE::ImageUsageFlags usage_ = {} ) VULKAN_HPP_NOEXCEPT : usage( usage_ ) {} @@ -41936,6 +45092,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImageViewUsageCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImageViewUsageCreateInfo*>( this ); @@ -41946,6 +45103,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImageViewUsageCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImageViewUsageCreateInfo const& ) const = default; #else @@ -41962,17 +45120,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImageViewUsageCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ImageUsageFlags usage = {}; + }; static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImageViewUsageCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImageViewUsageCreateInfo> + { + using Type = ImageViewUsageCreateInfo; + }; + #ifdef VK_USE_PLATFORM_ANDROID_KHR struct ImportAndroidHardwareBufferInfoANDROID { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportAndroidHardwareBufferInfoANDROID; + VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = {} ) VULKAN_HPP_NOEXCEPT : buffer( buffer_ ) {} @@ -42006,6 +45175,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImportAndroidHardwareBufferInfoANDROID const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>( this ); @@ -42016,6 +45186,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImportAndroidHardwareBufferInfoANDROID const& ) const = default; #else @@ -42032,17 +45203,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID; const void* pNext = {}; struct AHardwareBuffer* buffer = {}; + }; static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImportAndroidHardwareBufferInfoANDROID>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eImportAndroidHardwareBufferInfoANDROID> + { + using Type = ImportAndroidHardwareBufferInfoANDROID; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ struct ImportFenceFdInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportFenceFdInfoKHR; + VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( VULKAN_HPP_NAMESPACE::Fence fence_ = {}, VULKAN_HPP_NAMESPACE::FenceImportFlags flags_ = {}, VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd, @@ -42100,6 +45282,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImportFenceFdInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImportFenceFdInfoKHR*>( this ); @@ -42110,6 +45293,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImportFenceFdInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImportFenceFdInfoKHR const& ) const = default; #else @@ -42129,6 +45313,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportFenceFdInfoKHR; const void* pNext = {}; @@ -42136,13 +45322,22 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::FenceImportFlags flags = {}; VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd; int fd = {}; + }; static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImportFenceFdInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImportFenceFdInfoKHR> + { + using Type = ImportFenceFdInfoKHR; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct ImportFenceWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportFenceWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::Fence fence_ = {}, VULKAN_HPP_NAMESPACE::FenceImportFlags flags_ = {}, VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd, @@ -42208,6 +45403,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImportFenceWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( this ); @@ -42218,6 +45414,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImportFenceWin32HandleInfoKHR const& ) const = default; #else @@ -42238,6 +45435,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR; const void* pNext = {}; @@ -42246,13 +45445,22 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd; HANDLE handle = {}; LPCWSTR name = {}; + }; static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImportFenceWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eImportFenceWin32HandleInfoKHR> + { + using Type = ImportFenceWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ImportMemoryFdInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryFdInfoKHR; + VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, int fd_ = {} ) VULKAN_HPP_NOEXCEPT : handleType( handleType_ ) @@ -42294,6 +45502,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImportMemoryFdInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImportMemoryFdInfoKHR*>( this ); @@ -42304,6 +45513,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImportMemoryFdInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImportMemoryFdInfoKHR const& ) const = default; #else @@ -42321,17 +45531,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportMemoryFdInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd; int fd = {}; + }; static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImportMemoryFdInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImportMemoryFdInfoKHR> + { + using Type = ImportMemoryFdInfoKHR; + }; + struct ImportMemoryHostPointerInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryHostPointerInfoEXT; + VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, void* pHostPointer_ = {} ) VULKAN_HPP_NOEXCEPT : handleType( handleType_ ) @@ -42373,6 +45594,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImportMemoryHostPointerInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>( this ); @@ -42383,6 +45605,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImportMemoryHostPointerInfoEXT const& ) const = default; #else @@ -42400,18 +45623,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd; void* pHostPointer = {}; + }; static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImportMemoryHostPointerInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImportMemoryHostPointerInfoEXT> + { + using Type = ImportMemoryHostPointerInfoEXT; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct ImportMemoryWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, HANDLE handle_ = {}, LPCWSTR name_ = {} ) VULKAN_HPP_NOEXCEPT @@ -42461,6 +45695,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImportMemoryWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>( this ); @@ -42471,6 +45706,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImportMemoryWin32HandleInfoKHR const& ) const = default; #else @@ -42489,20 +45725,31 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd; HANDLE handle = {}; LPCWSTR name = {}; + }; static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImportMemoryWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eImportMemoryWin32HandleInfoKHR> + { + using Type = ImportMemoryWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR struct ImportMemoryWin32HandleInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryWin32HandleInfoNV; + VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType_ = {}, HANDLE handle_ = {} ) VULKAN_HPP_NOEXCEPT : handleType( handleType_ ) @@ -42544,6 +45791,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImportMemoryWin32HandleInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>( this ); @@ -42554,6 +45802,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImportMemoryWin32HandleInfoNV const& ) const = default; #else @@ -42571,18 +45820,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType = {}; HANDLE handle = {}; + }; static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImportMemoryWin32HandleInfoNV>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eImportMemoryWin32HandleInfoNV> + { + using Type = ImportMemoryWin32HandleInfoNV; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct ImportSemaphoreFdInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportSemaphoreFdInfoKHR; + VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {}, VULKAN_HPP_NAMESPACE::SemaphoreImportFlags flags_ = {}, VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, @@ -42640,6 +45900,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImportSemaphoreFdInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( this ); @@ -42650,6 +45911,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImportSemaphoreFdInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImportSemaphoreFdInfoKHR const& ) const = default; #else @@ -42669,6 +45931,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportSemaphoreFdInfoKHR; const void* pNext = {}; @@ -42676,13 +45940,22 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::SemaphoreImportFlags flags = {}; VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; int fd = {}; + }; static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImportSemaphoreFdInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eImportSemaphoreFdInfoKHR> + { + using Type = ImportSemaphoreFdInfoKHR; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct ImportSemaphoreWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportSemaphoreWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {}, VULKAN_HPP_NAMESPACE::SemaphoreImportFlags flags_ = {}, VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, @@ -42748,6 +46021,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkImportSemaphoreWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( this ); @@ -42758,6 +46032,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ImportSemaphoreWin32HandleInfoKHR const& ) const = default; #else @@ -42778,6 +46053,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR; const void* pNext = {}; @@ -42786,13 +46063,22 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; HANDLE handle = {}; LPCWSTR name = {}; + }; static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ImportSemaphoreWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eImportSemaphoreWin32HandleInfoKHR> + { + using Type = ImportSemaphoreWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct IndirectCommandsLayoutTokenNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutTokenNV; + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutTokenNV( VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV tokenType_ = VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV::eShaderGroup, uint32_t stream_ = {}, uint32_t offset_ = {}, @@ -42922,6 +46208,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkIndirectCommandsLayoutTokenNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNV*>( this ); @@ -42932,6 +46219,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkIndirectCommandsLayoutTokenNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( IndirectCommandsLayoutTokenNV const& ) const = default; #else @@ -42960,6 +46248,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eIndirectCommandsLayoutTokenNV; const void* pNext = {}; @@ -42976,12 +46266,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t indexTypeCount = {}; const VULKAN_HPP_NAMESPACE::IndexType* pIndexTypes = {}; const uint32_t* pIndexTypeValues = {}; + }; static_assert( sizeof( IndirectCommandsLayoutTokenNV ) == sizeof( VkIndirectCommandsLayoutTokenNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<IndirectCommandsLayoutTokenNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eIndirectCommandsLayoutTokenNV> + { + using Type = IndirectCommandsLayoutTokenNV; + }; + struct IndirectCommandsLayoutCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutCreateInfoNV; + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNV flags_ = {}, VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics, uint32_t tokenCount_ = {}, @@ -43055,6 +46354,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkIndirectCommandsLayoutCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV*>( this ); @@ -43065,6 +46365,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( IndirectCommandsLayoutCreateInfoNV const& ) const = default; #else @@ -43086,6 +46387,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNV; const void* pNext = {}; @@ -43095,12 +46398,21 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV* pTokens = {}; uint32_t streamCount = {}; const uint32_t* pStreamStrides = {}; + }; static_assert( sizeof( IndirectCommandsLayoutCreateInfoNV ) == sizeof( VkIndirectCommandsLayoutCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<IndirectCommandsLayoutCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eIndirectCommandsLayoutCreateInfoNV> + { + using Type = IndirectCommandsLayoutCreateInfoNV; + }; + struct InitializePerformanceApiInfoINTEL { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eInitializePerformanceApiInfoINTEL; + VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( void* pUserData_ = {} ) VULKAN_HPP_NOEXCEPT : pUserData( pUserData_ ) {} @@ -43134,6 +46446,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkInitializePerformanceApiInfoINTEL const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkInitializePerformanceApiInfoINTEL*>( this ); @@ -43144,6 +46457,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkInitializePerformanceApiInfoINTEL*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( InitializePerformanceApiInfoINTEL const& ) const = default; #else @@ -43160,16 +46474,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eInitializePerformanceApiInfoINTEL; const void* pNext = {}; void* pUserData = {}; + }; static_assert( sizeof( InitializePerformanceApiInfoINTEL ) == sizeof( VkInitializePerformanceApiInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<InitializePerformanceApiInfoINTEL>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eInitializePerformanceApiInfoINTEL> + { + using Type = InitializePerformanceApiInfoINTEL; + }; + struct InputAttachmentAspectReference { + VULKAN_HPP_CONSTEXPR InputAttachmentAspectReference( uint32_t subpass_ = {}, uint32_t inputAttachmentIndex_ = {}, VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {} ) VULKAN_HPP_NOEXCEPT @@ -43207,6 +46531,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkInputAttachmentAspectReference const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkInputAttachmentAspectReference*>( this ); @@ -43217,6 +46542,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkInputAttachmentAspectReference*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( InputAttachmentAspectReference const& ) const = default; #else @@ -43233,16 +46559,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t subpass = {}; uint32_t inputAttachmentIndex = {}; VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {}; + }; static_assert( sizeof( InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<InputAttachmentAspectReference>::value, "struct wrapper is not a standard layout!" ); struct InstanceCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eInstanceCreateInfo; + VULKAN_HPP_CONSTEXPR InstanceCreateInfo( VULKAN_HPP_NAMESPACE::InstanceCreateFlags flags_ = {}, const VULKAN_HPP_NAMESPACE::ApplicationInfo* pApplicationInfo_ = {}, uint32_t enabledLayerCount_ = {}, @@ -43316,6 +46647,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkInstanceCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkInstanceCreateInfo*>( this ); @@ -43326,6 +46658,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkInstanceCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( InstanceCreateInfo const& ) const = default; #else @@ -43347,6 +46680,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eInstanceCreateInfo; const void* pNext = {}; @@ -43356,12 +46691,20 @@ namespace VULKAN_HPP_NAMESPACE const char* const* ppEnabledLayerNames = {}; uint32_t enabledExtensionCount = {}; const char* const* ppEnabledExtensionNames = {}; + }; static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<InstanceCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eInstanceCreateInfo> + { + using Type = InstanceCreateInfo; + }; + struct LayerProperties { + VULKAN_HPP_CONSTEXPR_14 LayerProperties( std::array<char,VK_MAX_EXTENSION_NAME_SIZE> const& layerName_ = {}, uint32_t specVersion_ = {}, uint32_t implementationVersion_ = {}, @@ -43383,6 +46726,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkLayerProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkLayerProperties*>( this ); @@ -43393,6 +46737,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkLayerProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( LayerProperties const& ) const = default; #else @@ -43410,11 +46755,14 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> layerName = {}; uint32_t specVersion = {}; uint32_t implementationVersion = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {}; + }; static_assert( sizeof( LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<LayerProperties>::value, "struct wrapper is not a standard layout!" ); @@ -43422,6 +46770,8 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_MACOS_MVK struct MacOSSurfaceCreateInfoMVK { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMacosSurfaceCreateInfoMVK; + VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK flags_ = {}, const void* pView_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -43463,6 +46813,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMacOSSurfaceCreateInfoMVK const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( this ); @@ -43473,6 +46824,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MacOSSurfaceCreateInfoMVK const& ) const = default; #else @@ -43490,18 +46842,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK; const void* pNext = {}; VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK flags = {}; const void* pView = {}; + }; static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MacOSSurfaceCreateInfoMVK>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eMacosSurfaceCreateInfoMVK> + { + using Type = MacOSSurfaceCreateInfoMVK; + }; #endif /*VK_USE_PLATFORM_MACOS_MVK*/ struct MappedMemoryRange { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMappedMemoryRange; + VULKAN_HPP_CONSTEXPR MappedMemoryRange( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT @@ -43551,6 +46914,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMappedMemoryRange const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMappedMemoryRange*>( this ); @@ -43561,6 +46925,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMappedMemoryRange*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MappedMemoryRange const& ) const = default; #else @@ -43579,18 +46944,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMappedMemoryRange; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceMemory memory = {}; VULKAN_HPP_NAMESPACE::DeviceSize offset = {}; VULKAN_HPP_NAMESPACE::DeviceSize size = {}; + }; static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MappedMemoryRange>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eMappedMemoryRange> + { + using Type = MappedMemoryRange; + }; + struct MemoryAllocateFlagsInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryAllocateFlagsInfo; + VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( VULKAN_HPP_NAMESPACE::MemoryAllocateFlags flags_ = {}, uint32_t deviceMask_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -43632,6 +47008,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryAllocateFlagsInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryAllocateFlagsInfo*>( this ); @@ -43642,6 +47019,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryAllocateFlagsInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryAllocateFlagsInfo const& ) const = default; #else @@ -43659,17 +47037,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryAllocateFlagsInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::MemoryAllocateFlags flags = {}; uint32_t deviceMask = {}; + }; static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryAllocateFlagsInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eMemoryAllocateFlagsInfo> + { + using Type = MemoryAllocateFlagsInfo; + }; + struct MemoryAllocateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryAllocateInfo; + VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( VULKAN_HPP_NAMESPACE::DeviceSize allocationSize_ = {}, uint32_t memoryTypeIndex_ = {} ) VULKAN_HPP_NOEXCEPT : allocationSize( allocationSize_ ) @@ -43711,6 +47100,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryAllocateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryAllocateInfo*>( this ); @@ -43721,6 +47111,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryAllocateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryAllocateInfo const& ) const = default; #else @@ -43738,17 +47129,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryAllocateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceSize allocationSize = {}; uint32_t memoryTypeIndex = {}; + }; static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryAllocateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eMemoryAllocateInfo> + { + using Type = MemoryAllocateInfo; + }; + struct MemoryBarrier { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryBarrier; + VULKAN_HPP_CONSTEXPR MemoryBarrier( VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask_ = {}, VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask_ = {} ) VULKAN_HPP_NOEXCEPT : srcAccessMask( srcAccessMask_ ) @@ -43790,6 +47192,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryBarrier const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryBarrier*>( this ); @@ -43800,6 +47203,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryBarrier*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryBarrier const& ) const = default; #else @@ -43817,17 +47221,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryBarrier; const void* pNext = {}; VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask = {}; VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask = {}; + }; static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryBarrier>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eMemoryBarrier> + { + using Type = MemoryBarrier; + }; + struct MemoryDedicatedAllocateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryDedicatedAllocateInfo; + VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( VULKAN_HPP_NAMESPACE::Image image_ = {}, VULKAN_HPP_NAMESPACE::Buffer buffer_ = {} ) VULKAN_HPP_NOEXCEPT : image( image_ ) @@ -43869,6 +47284,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryDedicatedAllocateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>( this ); @@ -43879,6 +47295,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryDedicatedAllocateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryDedicatedAllocateInfo const& ) const = default; #else @@ -43896,17 +47313,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryDedicatedAllocateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Image image = {}; VULKAN_HPP_NAMESPACE::Buffer buffer = {}; + }; static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryDedicatedAllocateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eMemoryDedicatedAllocateInfo> + { + using Type = MemoryDedicatedAllocateInfo; + }; + struct MemoryDedicatedRequirements { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryDedicatedRequirements; + VULKAN_HPP_CONSTEXPR MemoryDedicatedRequirements( VULKAN_HPP_NAMESPACE::Bool32 prefersDedicatedAllocation_ = {}, VULKAN_HPP_NAMESPACE::Bool32 requiresDedicatedAllocation_ = {} ) VULKAN_HPP_NOEXCEPT : prefersDedicatedAllocation( prefersDedicatedAllocation_ ) @@ -43930,6 +47358,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryDedicatedRequirements const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryDedicatedRequirements*>( this ); @@ -43940,6 +47369,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryDedicatedRequirements*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryDedicatedRequirements const& ) const = default; #else @@ -43957,17 +47387,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryDedicatedRequirements; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 prefersDedicatedAllocation = {}; VULKAN_HPP_NAMESPACE::Bool32 requiresDedicatedAllocation = {}; + }; static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryDedicatedRequirements>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eMemoryDedicatedRequirements> + { + using Type = MemoryDedicatedRequirements; + }; + struct MemoryFdPropertiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryFdPropertiesKHR; + VULKAN_HPP_CONSTEXPR MemoryFdPropertiesKHR( uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT : memoryTypeBits( memoryTypeBits_ ) {} @@ -43989,6 +47430,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryFdPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryFdPropertiesKHR*>( this ); @@ -43999,6 +47441,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryFdPropertiesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryFdPropertiesKHR const& ) const = default; #else @@ -44015,17 +47458,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryFdPropertiesKHR; void* pNext = {}; uint32_t memoryTypeBits = {}; + }; static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryFdPropertiesKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eMemoryFdPropertiesKHR> + { + using Type = MemoryFdPropertiesKHR; + }; + #ifdef VK_USE_PLATFORM_ANDROID_KHR struct MemoryGetAndroidHardwareBufferInfoANDROID { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID; + VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {} ) VULKAN_HPP_NOEXCEPT : memory( memory_ ) {} @@ -44059,6 +47513,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryGetAndroidHardwareBufferInfoANDROID const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>( this ); @@ -44069,6 +47524,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryGetAndroidHardwareBufferInfoANDROID const& ) const = default; #else @@ -44085,17 +47541,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceMemory memory = {}; + }; static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryGetAndroidHardwareBufferInfoANDROID>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID> + { + using Type = MemoryGetAndroidHardwareBufferInfoANDROID; + }; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ struct MemoryGetFdInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetFdInfoKHR; + VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT : memory( memory_ ) @@ -44137,6 +47604,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryGetFdInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryGetFdInfoKHR*>( this ); @@ -44147,6 +47615,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryGetFdInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryGetFdInfoKHR const& ) const = default; #else @@ -44164,18 +47633,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryGetFdInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceMemory memory = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + }; static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryGetFdInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eMemoryGetFdInfoKHR> + { + using Type = MemoryGetFdInfoKHR; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct MemoryGetWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT : memory( memory_ ) @@ -44217,6 +47697,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryGetWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( this ); @@ -44227,6 +47708,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryGetWin32HandleInfoKHR const& ) const = default; #else @@ -44244,18 +47726,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceMemory memory = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + }; static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryGetWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eMemoryGetWin32HandleInfoKHR> + { + using Type = MemoryGetWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct MemoryHeap { + VULKAN_HPP_CONSTEXPR MemoryHeap( VULKAN_HPP_NAMESPACE::DeviceSize size_ = {}, VULKAN_HPP_NAMESPACE::MemoryHeapFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT : size( size_ ) @@ -44273,6 +47765,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryHeap const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryHeap*>( this ); @@ -44283,6 +47776,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryHeap*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryHeap const& ) const = default; #else @@ -44298,15 +47792,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::DeviceSize size = {}; VULKAN_HPP_NAMESPACE::MemoryHeapFlags flags = {}; + }; static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryHeap>::value, "struct wrapper is not a standard layout!" ); struct MemoryHostPointerPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryHostPointerPropertiesEXT; + VULKAN_HPP_CONSTEXPR MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT : memoryTypeBits( memoryTypeBits_ ) {} @@ -44328,6 +47827,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryHostPointerPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>( this ); @@ -44338,6 +47838,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryHostPointerPropertiesEXT const& ) const = default; #else @@ -44354,16 +47855,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT; void* pNext = {}; uint32_t memoryTypeBits = {}; + }; static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryHostPointerPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eMemoryHostPointerPropertiesEXT> + { + using Type = MemoryHostPointerPropertiesEXT; + }; + struct MemoryOpaqueCaptureAddressAllocateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryOpaqueCaptureAddressAllocateInfo; + VULKAN_HPP_CONSTEXPR MemoryOpaqueCaptureAddressAllocateInfo( uint64_t opaqueCaptureAddress_ = {} ) VULKAN_HPP_NOEXCEPT : opaqueCaptureAddress( opaqueCaptureAddress_ ) {} @@ -44397,6 +47909,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryOpaqueCaptureAddressAllocateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>( this ); @@ -44407,6 +47920,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryOpaqueCaptureAddressAllocateInfo const& ) const = default; #else @@ -44423,16 +47937,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryOpaqueCaptureAddressAllocateInfo; const void* pNext = {}; uint64_t opaqueCaptureAddress = {}; + }; static_assert( sizeof( MemoryOpaqueCaptureAddressAllocateInfo ) == sizeof( VkMemoryOpaqueCaptureAddressAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryOpaqueCaptureAddressAllocateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eMemoryOpaqueCaptureAddressAllocateInfo> + { + using Type = MemoryOpaqueCaptureAddressAllocateInfo; + }; + struct MemoryPriorityAllocateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryPriorityAllocateInfoEXT; + VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( float priority_ = {} ) VULKAN_HPP_NOEXCEPT : priority( priority_ ) {} @@ -44466,6 +47991,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryPriorityAllocateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>( this ); @@ -44476,6 +48002,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryPriorityAllocateInfoEXT const& ) const = default; #else @@ -44492,16 +48019,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT; const void* pNext = {}; float priority = {}; + }; static_assert( sizeof( MemoryPriorityAllocateInfoEXT ) == sizeof( VkMemoryPriorityAllocateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryPriorityAllocateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eMemoryPriorityAllocateInfoEXT> + { + using Type = MemoryPriorityAllocateInfoEXT; + }; + struct MemoryRequirements { + VULKAN_HPP_CONSTEXPR MemoryRequirements( VULKAN_HPP_NAMESPACE::DeviceSize size_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize alignment_ = {}, uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT @@ -44521,6 +48058,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryRequirements const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryRequirements*>( this ); @@ -44531,6 +48069,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryRequirements*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryRequirements const& ) const = default; #else @@ -44547,16 +48086,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::DeviceSize size = {}; VULKAN_HPP_NAMESPACE::DeviceSize alignment = {}; uint32_t memoryTypeBits = {}; + }; static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryRequirements>::value, "struct wrapper is not a standard layout!" ); struct MemoryRequirements2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryRequirements2; + VULKAN_HPP_CONSTEXPR MemoryRequirements2( VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements_ = {} ) VULKAN_HPP_NOEXCEPT : memoryRequirements( memoryRequirements_ ) {} @@ -44578,6 +48122,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryRequirements2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryRequirements2*>( this ); @@ -44588,6 +48133,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryRequirements2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryRequirements2 const& ) const = default; #else @@ -44604,16 +48150,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryRequirements2; void* pNext = {}; VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements = {}; + }; static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryRequirements2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eMemoryRequirements2> + { + using Type = MemoryRequirements2; + }; + struct MemoryType { + VULKAN_HPP_CONSTEXPR MemoryType( VULKAN_HPP_NAMESPACE::MemoryPropertyFlags propertyFlags_ = {}, uint32_t heapIndex_ = {} ) VULKAN_HPP_NOEXCEPT : propertyFlags( propertyFlags_ ) @@ -44631,6 +48187,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryType const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryType*>( this ); @@ -44641,6 +48198,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryType*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryType const& ) const = default; #else @@ -44656,9 +48214,12 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::MemoryPropertyFlags propertyFlags = {}; uint32_t heapIndex = {}; + }; static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryType>::value, "struct wrapper is not a standard layout!" ); @@ -44666,6 +48227,8 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR struct MemoryWin32HandlePropertiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryWin32HandlePropertiesKHR; + VULKAN_HPP_CONSTEXPR MemoryWin32HandlePropertiesKHR( uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT : memoryTypeBits( memoryTypeBits_ ) {} @@ -44687,6 +48250,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMemoryWin32HandlePropertiesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>( this ); @@ -44697,6 +48261,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MemoryWin32HandlePropertiesKHR const& ) const = default; #else @@ -44713,18 +48278,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR; void* pNext = {}; uint32_t memoryTypeBits = {}; + }; static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MemoryWin32HandlePropertiesKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eMemoryWin32HandlePropertiesKHR> + { + using Type = MemoryWin32HandlePropertiesKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_METAL_EXT struct MetalSurfaceCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMetalSurfaceCreateInfoEXT; + VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT flags_ = {}, const CAMetalLayer* pLayer_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -44766,6 +48342,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMetalSurfaceCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMetalSurfaceCreateInfoEXT*>( this ); @@ -44776,6 +48353,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMetalSurfaceCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MetalSurfaceCreateInfoEXT const& ) const = default; #else @@ -44793,18 +48371,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMetalSurfaceCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT flags = {}; const CAMetalLayer* pLayer = {}; + }; static_assert( sizeof( MetalSurfaceCreateInfoEXT ) == sizeof( VkMetalSurfaceCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MetalSurfaceCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eMetalSurfaceCreateInfoEXT> + { + using Type = MetalSurfaceCreateInfoEXT; + }; #endif /*VK_USE_PLATFORM_METAL_EXT*/ struct MultisamplePropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMultisamplePropertiesEXT; + VULKAN_HPP_CONSTEXPR MultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::Extent2D maxSampleLocationGridSize_ = {} ) VULKAN_HPP_NOEXCEPT : maxSampleLocationGridSize( maxSampleLocationGridSize_ ) {} @@ -44826,6 +48415,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkMultisamplePropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkMultisamplePropertiesEXT*>( this ); @@ -44836,6 +48426,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkMultisamplePropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( MultisamplePropertiesEXT const& ) const = default; #else @@ -44852,16 +48443,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMultisamplePropertiesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Extent2D maxSampleLocationGridSize = {}; + }; static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<MultisamplePropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eMultisamplePropertiesEXT> + { + using Type = MultisamplePropertiesEXT; + }; + struct PastPresentationTimingGOOGLE { + VULKAN_HPP_CONSTEXPR PastPresentationTimingGOOGLE( uint32_t presentID_ = {}, uint64_t desiredPresentTime_ = {}, uint64_t actualPresentTime_ = {}, @@ -44885,6 +48486,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPastPresentationTimingGOOGLE const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPastPresentationTimingGOOGLE*>( this ); @@ -44895,6 +48497,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPastPresentationTimingGOOGLE*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PastPresentationTimingGOOGLE const& ) const = default; #else @@ -44913,18 +48516,23 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t presentID = {}; uint64_t desiredPresentTime = {}; uint64_t actualPresentTime = {}; uint64_t earliestPresentTime = {}; uint64_t presentMargin = {}; + }; static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PastPresentationTimingGOOGLE>::value, "struct wrapper is not a standard layout!" ); struct PerformanceConfigurationAcquireInfoINTEL { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceConfigurationAcquireInfoINTEL; + VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL type_ = VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated ) VULKAN_HPP_NOEXCEPT : type( type_ ) {} @@ -44958,6 +48566,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPerformanceConfigurationAcquireInfoINTEL const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL*>( this ); @@ -44968,6 +48577,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PerformanceConfigurationAcquireInfoINTEL const& ) const = default; #else @@ -44984,16 +48594,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceConfigurationAcquireInfoINTEL; const void* pNext = {}; VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated; + }; static_assert( sizeof( PerformanceConfigurationAcquireInfoINTEL ) == sizeof( VkPerformanceConfigurationAcquireInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PerformanceConfigurationAcquireInfoINTEL>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePerformanceConfigurationAcquireInfoINTEL> + { + using Type = PerformanceConfigurationAcquireInfoINTEL; + }; + struct PerformanceCounterDescriptionKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceCounterDescriptionKHR; + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterDescriptionKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR flags_ = {}, std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = {}, std::array<char,VK_MAX_DESCRIPTION_SIZE> const& category_ = {}, @@ -45021,6 +48642,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPerformanceCounterDescriptionKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPerformanceCounterDescriptionKHR*>( this ); @@ -45031,6 +48653,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPerformanceCounterDescriptionKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PerformanceCounterDescriptionKHR const& ) const = default; #else @@ -45050,6 +48673,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceCounterDescriptionKHR; const void* pNext = {}; @@ -45057,12 +48682,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> name = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> category = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {}; + }; static_assert( sizeof( PerformanceCounterDescriptionKHR ) == sizeof( VkPerformanceCounterDescriptionKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PerformanceCounterDescriptionKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePerformanceCounterDescriptionKHR> + { + using Type = PerformanceCounterDescriptionKHR; + }; + struct PerformanceCounterKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceCounterKHR; + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR unit_ = VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR::eGeneric, VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR scope_ = VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR::eCommandBuffer, VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR storage_ = VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR::eInt32, @@ -45090,6 +48724,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPerformanceCounterKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPerformanceCounterKHR*>( this ); @@ -45100,6 +48735,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPerformanceCounterKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PerformanceCounterKHR const& ) const = default; #else @@ -45119,6 +48755,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceCounterKHR; const void* pNext = {}; @@ -45126,10 +48764,17 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR scope = VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR::eCommandBuffer; VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR storage = VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR::eInt32; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> uuid = {}; + }; static_assert( sizeof( PerformanceCounterKHR ) == sizeof( VkPerformanceCounterKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PerformanceCounterKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePerformanceCounterKHR> + { + using Type = PerformanceCounterKHR; + }; + union PerformanceCounterResultKHR { PerformanceCounterResultKHR( VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR const& rhs ) VULKAN_HPP_NOEXCEPT @@ -45138,34 +48783,28 @@ namespace VULKAN_HPP_NAMESPACE } PerformanceCounterResultKHR( int32_t int32_ = {} ) - { - int32 = int32_; - } + : int32( int32_ ) + {} PerformanceCounterResultKHR( int64_t int64_ ) - { - int64 = int64_; - } + : int64( int64_ ) + {} PerformanceCounterResultKHR( uint32_t uint32_ ) - { - uint32 = uint32_; - } + : uint32( uint32_ ) + {} PerformanceCounterResultKHR( uint64_t uint64_ ) - { - uint64 = uint64_; - } + : uint64( uint64_ ) + {} PerformanceCounterResultKHR( float float32_ ) - { - float32 = float32_; - } + : float32( float32_ ) + {} PerformanceCounterResultKHR( double float64_ ) - { - float64 = float64_; - } + : float64( float64_ ) + {} PerformanceCounterResultKHR & setInt32( int32_t int32_ ) VULKAN_HPP_NOEXCEPT { @@ -45229,6 +48868,8 @@ namespace VULKAN_HPP_NAMESPACE struct PerformanceMarkerInfoINTEL { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceMarkerInfoINTEL; + VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( uint64_t marker_ = {} ) VULKAN_HPP_NOEXCEPT : marker( marker_ ) {} @@ -45262,6 +48903,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPerformanceMarkerInfoINTEL const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPerformanceMarkerInfoINTEL*>( this ); @@ -45272,6 +48914,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPerformanceMarkerInfoINTEL*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PerformanceMarkerInfoINTEL const& ) const = default; #else @@ -45288,16 +48931,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceMarkerInfoINTEL; const void* pNext = {}; uint64_t marker = {}; + }; static_assert( sizeof( PerformanceMarkerInfoINTEL ) == sizeof( VkPerformanceMarkerInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PerformanceMarkerInfoINTEL>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePerformanceMarkerInfoINTEL> + { + using Type = PerformanceMarkerInfoINTEL; + }; + struct PerformanceOverrideInfoINTEL { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceOverrideInfoINTEL; + VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL type_ = VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL::eNullHardware, VULKAN_HPP_NAMESPACE::Bool32 enable_ = {}, uint64_t parameter_ = {} ) VULKAN_HPP_NOEXCEPT @@ -45347,6 +49001,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPerformanceOverrideInfoINTEL const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPerformanceOverrideInfoINTEL*>( this ); @@ -45357,6 +49012,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPerformanceOverrideInfoINTEL*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PerformanceOverrideInfoINTEL const& ) const = default; #else @@ -45375,18 +49031,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceOverrideInfoINTEL; const void* pNext = {}; VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL type = VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL::eNullHardware; VULKAN_HPP_NAMESPACE::Bool32 enable = {}; uint64_t parameter = {}; + }; static_assert( sizeof( PerformanceOverrideInfoINTEL ) == sizeof( VkPerformanceOverrideInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PerformanceOverrideInfoINTEL>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePerformanceOverrideInfoINTEL> + { + using Type = PerformanceOverrideInfoINTEL; + }; + struct PerformanceQuerySubmitInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceQuerySubmitInfoKHR; + VULKAN_HPP_CONSTEXPR PerformanceQuerySubmitInfoKHR( uint32_t counterPassIndex_ = {} ) VULKAN_HPP_NOEXCEPT : counterPassIndex( counterPassIndex_ ) {} @@ -45420,6 +49087,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPerformanceQuerySubmitInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>( this ); @@ -45430,6 +49098,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PerformanceQuerySubmitInfoKHR const& ) const = default; #else @@ -45446,16 +49115,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceQuerySubmitInfoKHR; const void* pNext = {}; uint32_t counterPassIndex = {}; + }; static_assert( sizeof( PerformanceQuerySubmitInfoKHR ) == sizeof( VkPerformanceQuerySubmitInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PerformanceQuerySubmitInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePerformanceQuerySubmitInfoKHR> + { + using Type = PerformanceQuerySubmitInfoKHR; + }; + struct PerformanceStreamMarkerInfoINTEL { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceStreamMarkerInfoINTEL; + VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = {} ) VULKAN_HPP_NOEXCEPT : marker( marker_ ) {} @@ -45489,6 +49169,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPerformanceStreamMarkerInfoINTEL const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL*>( this ); @@ -45499,6 +49180,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PerformanceStreamMarkerInfoINTEL const& ) const = default; #else @@ -45515,14 +49197,23 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerformanceStreamMarkerInfoINTEL; const void* pNext = {}; uint32_t marker = {}; + }; static_assert( sizeof( PerformanceStreamMarkerInfoINTEL ) == sizeof( VkPerformanceStreamMarkerInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PerformanceStreamMarkerInfoINTEL>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePerformanceStreamMarkerInfoINTEL> + { + using Type = PerformanceStreamMarkerInfoINTEL; + }; + union PerformanceValueDataINTEL { PerformanceValueDataINTEL( VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL const& rhs ) VULKAN_HPP_NOEXCEPT @@ -45531,24 +49222,20 @@ namespace VULKAN_HPP_NAMESPACE } PerformanceValueDataINTEL( uint32_t value32_ = {} ) - { - value32 = value32_; - } + : value32( value32_ ) + {} PerformanceValueDataINTEL( uint64_t value64_ ) - { - value64 = value64_; - } + : value64( value64_ ) + {} PerformanceValueDataINTEL( float valueFloat_ ) - { - valueFloat = valueFloat_; - } + : valueFloat( valueFloat_ ) + {} PerformanceValueDataINTEL( const char* valueString_ ) - { - valueString = valueString_; - } + : valueString( valueString_ ) + {} PerformanceValueDataINTEL & setValue32( uint32_t value32_ ) VULKAN_HPP_NOEXCEPT { @@ -45613,6 +49300,7 @@ namespace VULKAN_HPP_NAMESPACE struct PerformanceValueINTEL { + PerformanceValueINTEL( VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL type_ = VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL::eUint32, VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL data_ = {} ) VULKAN_HPP_NOEXCEPT : type( type_ ) @@ -45636,12 +49324,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - PerformanceValueINTEL & setData( VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL data_ ) VULKAN_HPP_NOEXCEPT + PerformanceValueINTEL & setData( VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL const & data_ ) VULKAN_HPP_NOEXCEPT { data = data_; return *this; } + operator VkPerformanceValueINTEL const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPerformanceValueINTEL*>( this ); @@ -45652,15 +49341,21 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPerformanceValueINTEL*>( this ); } + + + public: VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL type = VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL::eUint32; VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL data = {}; + }; static_assert( sizeof( PerformanceValueINTEL ) == sizeof( VkPerformanceValueINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PerformanceValueINTEL>::value, "struct wrapper is not a standard layout!" ); struct PhysicalDevice16BitStorageFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevice16BitStorageFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( VULKAN_HPP_NAMESPACE::Bool32 storageBuffer16BitAccess_ = {}, VULKAN_HPP_NAMESPACE::Bool32 uniformAndStorageBuffer16BitAccess_ = {}, VULKAN_HPP_NAMESPACE::Bool32 storagePushConstant16_ = {}, @@ -45718,6 +49413,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDevice16BitStorageFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>( this ); @@ -45728,6 +49424,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDevice16BitStorageFeatures const& ) const = default; #else @@ -45747,6 +49444,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevice16BitStorageFeatures; void* pNext = {}; @@ -45754,12 +49453,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 uniformAndStorageBuffer16BitAccess = {}; VULKAN_HPP_NAMESPACE::Bool32 storagePushConstant16 = {}; VULKAN_HPP_NAMESPACE::Bool32 storageInputOutput16 = {}; + }; static_assert( sizeof( PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDevice16BitStorageFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDevice16BitStorageFeatures> + { + using Type = PhysicalDevice16BitStorageFeatures; + }; + struct PhysicalDevice8BitStorageFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevice8BitStorageFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeatures( VULKAN_HPP_NAMESPACE::Bool32 storageBuffer8BitAccess_ = {}, VULKAN_HPP_NAMESPACE::Bool32 uniformAndStorageBuffer8BitAccess_ = {}, VULKAN_HPP_NAMESPACE::Bool32 storagePushConstant8_ = {} ) VULKAN_HPP_NOEXCEPT @@ -45809,6 +49517,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDevice8BitStorageFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>( this ); @@ -45819,6 +49528,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDevice8BitStorageFeatures const& ) const = default; #else @@ -45837,18 +49547,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevice8BitStorageFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 storageBuffer8BitAccess = {}; VULKAN_HPP_NAMESPACE::Bool32 uniformAndStorageBuffer8BitAccess = {}; VULKAN_HPP_NAMESPACE::Bool32 storagePushConstant8 = {}; + }; static_assert( sizeof( PhysicalDevice8BitStorageFeatures ) == sizeof( VkPhysicalDevice8BitStorageFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDevice8BitStorageFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDevice8BitStorageFeatures> + { + using Type = PhysicalDevice8BitStorageFeatures; + }; + struct PhysicalDeviceASTCDecodeFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 decodeModeSharedExponent_ = {} ) VULKAN_HPP_NOEXCEPT : decodeModeSharedExponent( decodeModeSharedExponent_ ) {} @@ -45882,6 +49603,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceASTCDecodeFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>( this ); @@ -45892,6 +49614,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceASTCDecodeFeaturesEXT const& ) const = default; #else @@ -45908,16 +49631,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 decodeModeSharedExponent = {}; + }; static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceASTCDecodeFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT> + { + using Type = PhysicalDeviceASTCDecodeFeaturesEXT; + }; + struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 advancedBlendCoherentOperations_ = {} ) VULKAN_HPP_NOEXCEPT : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ ) {} @@ -45951,6 +49685,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>( this ); @@ -45961,6 +49696,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& ) const = default; #else @@ -45977,16 +49713,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 advancedBlendCoherentOperations = {}; + }; static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceBlendOperationAdvancedFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT> + { + using Type = PhysicalDeviceBlendOperationAdvancedFeaturesEXT; + }; + struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedPropertiesEXT( uint32_t advancedBlendMaxColorAttachments_ = {}, VULKAN_HPP_NAMESPACE::Bool32 advancedBlendIndependentBlend_ = {}, VULKAN_HPP_NAMESPACE::Bool32 advancedBlendNonPremultipliedSrcColor_ = {}, @@ -46018,6 +49765,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>( this ); @@ -46028,6 +49776,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& ) const = default; #else @@ -46049,6 +49798,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; void* pNext = {}; @@ -46058,12 +49809,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 advancedBlendNonPremultipliedDstColor = {}; VULKAN_HPP_NAMESPACE::Bool32 advancedBlendCorrelatedOverlap = {}; VULKAN_HPP_NAMESPACE::Bool32 advancedBlendAllOperations = {}; + }; static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceBlendOperationAdvancedPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT> + { + using Type = PhysicalDeviceBlendOperationAdvancedPropertiesEXT; + }; + struct PhysicalDeviceBufferDeviceAddressFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBufferDeviceAddressFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeatures( VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddress_ = {}, VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressCaptureReplay_ = {}, VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressMultiDevice_ = {} ) VULKAN_HPP_NOEXCEPT @@ -46113,6 +49873,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceBufferDeviceAddressFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>( this ); @@ -46123,6 +49884,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceBufferDeviceAddressFeatures const& ) const = default; #else @@ -46141,18 +49903,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddress = {}; VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressCaptureReplay = {}; VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressMultiDevice = {}; + }; static_assert( sizeof( PhysicalDeviceBufferDeviceAddressFeatures ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceBufferDeviceAddressFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceBufferDeviceAddressFeatures> + { + using Type = PhysicalDeviceBufferDeviceAddressFeatures; + }; + struct PhysicalDeviceBufferDeviceAddressFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddress_ = {}, VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressCaptureReplay_ = {}, VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressMultiDevice_ = {} ) VULKAN_HPP_NOEXCEPT @@ -46202,6 +49975,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>( this ); @@ -46212,6 +49986,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceBufferDeviceAddressFeaturesEXT const& ) const = default; #else @@ -46230,18 +50005,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddress = {}; VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressCaptureReplay = {}; VULKAN_HPP_NAMESPACE::Bool32 bufferDeviceAddressMultiDevice = {}; + }; static_assert( sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceBufferDeviceAddressFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT> + { + using Type = PhysicalDeviceBufferDeviceAddressFeaturesEXT; + }; + struct PhysicalDeviceCoherentMemoryFeaturesAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD; + VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( VULKAN_HPP_NAMESPACE::Bool32 deviceCoherentMemory_ = {} ) VULKAN_HPP_NOEXCEPT : deviceCoherentMemory( deviceCoherentMemory_ ) {} @@ -46275,6 +50061,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>( this ); @@ -46285,6 +50072,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceCoherentMemoryFeaturesAMD const& ) const = default; #else @@ -46301,16 +50089,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 deviceCoherentMemory = {}; + }; static_assert( sizeof( PhysicalDeviceCoherentMemoryFeaturesAMD ) == sizeof( VkPhysicalDeviceCoherentMemoryFeaturesAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceCoherentMemoryFeaturesAMD>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD> + { + using Type = PhysicalDeviceCoherentMemoryFeaturesAMD; + }; + struct PhysicalDeviceComputeShaderDerivativesFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 computeDerivativeGroupQuads_ = {}, VULKAN_HPP_NAMESPACE::Bool32 computeDerivativeGroupLinear_ = {} ) VULKAN_HPP_NOEXCEPT : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ ) @@ -46352,6 +50151,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>( this ); @@ -46362,6 +50162,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceComputeShaderDerivativesFeaturesNV const& ) const = default; #else @@ -46379,17 +50180,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 computeDerivativeGroupQuads = {}; VULKAN_HPP_NAMESPACE::Bool32 computeDerivativeGroupLinear = {}; + }; static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceComputeShaderDerivativesFeaturesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV> + { + using Type = PhysicalDeviceComputeShaderDerivativesFeaturesNV; + }; + struct PhysicalDeviceConditionalRenderingFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 conditionalRendering_ = {}, VULKAN_HPP_NAMESPACE::Bool32 inheritedConditionalRendering_ = {} ) VULKAN_HPP_NOEXCEPT : conditionalRendering( conditionalRendering_ ) @@ -46431,6 +50243,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>( this ); @@ -46441,6 +50254,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceConditionalRenderingFeaturesEXT const& ) const = default; #else @@ -46458,17 +50272,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 conditionalRendering = {}; VULKAN_HPP_NAMESPACE::Bool32 inheritedConditionalRendering = {}; + }; static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceConditionalRenderingFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT> + { + using Type = PhysicalDeviceConditionalRenderingFeaturesEXT; + }; + struct PhysicalDeviceConservativeRasterizationPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceConservativeRasterizationPropertiesEXT( float primitiveOverestimationSize_ = {}, float maxExtraPrimitiveOverestimationSize_ = {}, float extraPrimitiveOverestimationSizeGranularity_ = {}, @@ -46506,6 +50331,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>( this ); @@ -46516,6 +50342,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceConservativeRasterizationPropertiesEXT const& ) const = default; #else @@ -46540,6 +50367,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT; void* pNext = {}; @@ -46552,12 +50381,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 degenerateLinesRasterized = {}; VULKAN_HPP_NAMESPACE::Bool32 fullyCoveredFragmentShaderInputVariable = {}; VULKAN_HPP_NAMESPACE::Bool32 conservativeRasterizationPostDepthCoverage = {}; + }; static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceConservativeRasterizationPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT> + { + using Type = PhysicalDeviceConservativeRasterizationPropertiesEXT; + }; + struct PhysicalDeviceCooperativeMatrixFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrix_ = {}, VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixRobustBufferAccess_ = {} ) VULKAN_HPP_NOEXCEPT : cooperativeMatrix( cooperativeMatrix_ ) @@ -46599,6 +50437,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceCooperativeMatrixFeaturesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>( this ); @@ -46609,6 +50448,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceCooperativeMatrixFeaturesNV const& ) const = default; #else @@ -46626,17 +50466,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrix = {}; VULKAN_HPP_NAMESPACE::Bool32 cooperativeMatrixRobustBufferAccess = {}; + }; static_assert( sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceCooperativeMatrixFeaturesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV> + { + using Type = PhysicalDeviceCooperativeMatrixFeaturesNV; + }; + struct PhysicalDeviceCooperativeMatrixPropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixPropertiesNV( VULKAN_HPP_NAMESPACE::ShaderStageFlags cooperativeMatrixSupportedStages_ = {} ) VULKAN_HPP_NOEXCEPT : cooperativeMatrixSupportedStages( cooperativeMatrixSupportedStages_ ) {} @@ -46658,6 +50509,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>( this ); @@ -46668,6 +50520,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceCooperativeMatrixPropertiesNV const& ) const = default; #else @@ -46684,16 +50537,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::ShaderStageFlags cooperativeMatrixSupportedStages = {}; + }; static_assert( sizeof( PhysicalDeviceCooperativeMatrixPropertiesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceCooperativeMatrixPropertiesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV> + { + using Type = PhysicalDeviceCooperativeMatrixPropertiesNV; + }; + struct PhysicalDeviceCornerSampledImageFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 cornerSampledImage_ = {} ) VULKAN_HPP_NOEXCEPT : cornerSampledImage( cornerSampledImage_ ) {} @@ -46727,6 +50591,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceCornerSampledImageFeaturesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>( this ); @@ -46737,6 +50602,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceCornerSampledImageFeaturesNV const& ) const = default; #else @@ -46753,16 +50619,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 cornerSampledImage = {}; + }; static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceCornerSampledImageFeaturesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV> + { + using Type = PhysicalDeviceCornerSampledImageFeaturesNV; + }; + struct PhysicalDeviceCoverageReductionModeFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 coverageReductionMode_ = {} ) VULKAN_HPP_NOEXCEPT : coverageReductionMode( coverageReductionMode_ ) {} @@ -46796,6 +50673,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceCoverageReductionModeFeaturesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>( this ); @@ -46806,6 +50684,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceCoverageReductionModeFeaturesNV const& ) const = default; #else @@ -46822,16 +50701,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 coverageReductionMode = {}; + }; static_assert( sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) == sizeof( VkPhysicalDeviceCoverageReductionModeFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceCoverageReductionModeFeaturesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV> + { + using Type = PhysicalDeviceCoverageReductionModeFeaturesNV; + }; + struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocationImageAliasing_ = {} ) VULKAN_HPP_NOEXCEPT : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ ) {} @@ -46865,6 +50755,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>( this ); @@ -46875,6 +50766,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const& ) const = default; #else @@ -46891,16 +50783,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 dedicatedAllocationImageAliasing = {}; + }; static_assert( sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) == sizeof( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV> + { + using Type = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + }; + struct PhysicalDeviceDepthClipEnableFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable_ = {} ) VULKAN_HPP_NOEXCEPT : depthClipEnable( depthClipEnable_ ) {} @@ -46934,6 +50837,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceDepthClipEnableFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>( this ); @@ -46944,6 +50848,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceDepthClipEnableFeaturesEXT const& ) const = default; #else @@ -46960,16 +50865,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable = {}; + }; static_assert( sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipEnableFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceDepthClipEnableFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT> + { + using Type = PhysicalDeviceDepthClipEnableFeaturesEXT; + }; + struct PhysicalDeviceDepthStencilResolveProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthStencilResolveProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthStencilResolveProperties( VULKAN_HPP_NAMESPACE::ResolveModeFlags supportedDepthResolveModes_ = {}, VULKAN_HPP_NAMESPACE::ResolveModeFlags supportedStencilResolveModes_ = {}, VULKAN_HPP_NAMESPACE::Bool32 independentResolveNone_ = {}, @@ -46997,6 +50913,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceDepthStencilResolveProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>( this ); @@ -47007,6 +50924,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceDepthStencilResolveProperties const& ) const = default; #else @@ -47026,6 +50944,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDepthStencilResolveProperties; void* pNext = {}; @@ -47033,12 +50953,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ResolveModeFlags supportedStencilResolveModes = {}; VULKAN_HPP_NAMESPACE::Bool32 independentResolveNone = {}; VULKAN_HPP_NAMESPACE::Bool32 independentResolve = {}; + }; static_assert( sizeof( PhysicalDeviceDepthStencilResolveProperties ) == sizeof( VkPhysicalDeviceDepthStencilResolveProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceDepthStencilResolveProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceDepthStencilResolveProperties> + { + using Type = PhysicalDeviceDepthStencilResolveProperties; + }; + struct PhysicalDeviceDescriptorIndexingFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorIndexingFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeatures( VULKAN_HPP_NAMESPACE::Bool32 shaderInputAttachmentArrayDynamicIndexing_ = {}, VULKAN_HPP_NAMESPACE::Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = {}, VULKAN_HPP_NAMESPACE::Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = {}, @@ -47224,6 +51153,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceDescriptorIndexingFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>( this ); @@ -47234,6 +51164,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceDescriptorIndexingFeatures const& ) const = default; #else @@ -47269,6 +51200,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingFeatures; void* pNext = {}; @@ -47292,12 +51225,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 descriptorBindingPartiallyBound = {}; VULKAN_HPP_NAMESPACE::Bool32 descriptorBindingVariableDescriptorCount = {}; VULKAN_HPP_NAMESPACE::Bool32 runtimeDescriptorArray = {}; + }; static_assert( sizeof( PhysicalDeviceDescriptorIndexingFeatures ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceDescriptorIndexingFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceDescriptorIndexingFeatures> + { + using Type = PhysicalDeviceDescriptorIndexingFeatures; + }; + struct PhysicalDeviceDescriptorIndexingProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorIndexingProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingProperties( uint32_t maxUpdateAfterBindDescriptorsInAllPools_ = {}, VULKAN_HPP_NAMESPACE::Bool32 shaderUniformBufferArrayNonUniformIndexingNative_ = {}, VULKAN_HPP_NAMESPACE::Bool32 shaderSampledImageArrayNonUniformIndexingNative_ = {}, @@ -47363,6 +51305,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceDescriptorIndexingProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>( this ); @@ -47373,6 +51316,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceDescriptorIndexingProperties const& ) const = default; #else @@ -47411,6 +51355,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingProperties; void* pNext = {}; @@ -47437,12 +51383,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t maxDescriptorSetUpdateAfterBindSampledImages = {}; uint32_t maxDescriptorSetUpdateAfterBindStorageImages = {}; uint32_t maxDescriptorSetUpdateAfterBindInputAttachments = {}; + }; static_assert( sizeof( PhysicalDeviceDescriptorIndexingProperties ) == sizeof( VkPhysicalDeviceDescriptorIndexingProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceDescriptorIndexingProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceDescriptorIndexingProperties> + { + using Type = PhysicalDeviceDescriptorIndexingProperties; + }; + struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 deviceGeneratedCommands_ = {} ) VULKAN_HPP_NOEXCEPT : deviceGeneratedCommands( deviceGeneratedCommands_ ) {} @@ -47476,6 +51431,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>( this ); @@ -47486,6 +51442,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const& ) const = default; #else @@ -47502,16 +51459,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 deviceGeneratedCommands = {}; + }; static_assert( sizeof( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV ) == sizeof( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV> + { + using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + }; + struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsPropertiesNV( uint32_t maxGraphicsShaderGroupCount_ = {}, uint32_t maxIndirectSequenceCount_ = {}, uint32_t maxIndirectCommandsTokenCount_ = {}, @@ -47549,6 +51517,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>( this ); @@ -47559,6 +51528,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const& ) const = default; #else @@ -47583,6 +51553,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV; void* pNext = {}; @@ -47595,12 +51567,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t minSequencesCountBufferOffsetAlignment = {}; uint32_t minSequencesIndexBufferOffsetAlignment = {}; uint32_t minIndirectCommandsBufferOffsetAlignment = {}; + }; static_assert( sizeof( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV ) == sizeof( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceDeviceGeneratedCommandsPropertiesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV> + { + using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + }; + struct PhysicalDeviceDiagnosticsConfigFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDiagnosticsConfigFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 diagnosticsConfig_ = {} ) VULKAN_HPP_NOEXCEPT : diagnosticsConfig( diagnosticsConfig_ ) {} @@ -47634,6 +51615,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>( this ); @@ -47644,6 +51626,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceDiagnosticsConfigFeaturesNV const& ) const = default; #else @@ -47660,16 +51643,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 diagnosticsConfig = {}; + }; static_assert( sizeof( PhysicalDeviceDiagnosticsConfigFeaturesNV ) == sizeof( VkPhysicalDeviceDiagnosticsConfigFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceDiagnosticsConfigFeaturesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV> + { + using Type = PhysicalDeviceDiagnosticsConfigFeaturesNV; + }; + struct PhysicalDeviceDiscardRectanglePropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = {} ) VULKAN_HPP_NOEXCEPT : maxDiscardRectangles( maxDiscardRectangles_ ) {} @@ -47691,6 +51685,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>( this ); @@ -47701,6 +51696,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceDiscardRectanglePropertiesEXT const& ) const = default; #else @@ -47717,16 +51713,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; void* pNext = {}; uint32_t maxDiscardRectangles = {}; + }; static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceDiscardRectanglePropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT> + { + using Type = PhysicalDeviceDiscardRectanglePropertiesEXT; + }; + struct PhysicalDeviceDriverProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDriverProperties; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDriverProperties( VULKAN_HPP_NAMESPACE::DriverId driverID_ = VULKAN_HPP_NAMESPACE::DriverId::eAmdProprietary, std::array<char,VK_MAX_DRIVER_NAME_SIZE> const& driverName_ = {}, std::array<char,VK_MAX_DRIVER_INFO_SIZE> const& driverInfo_ = {}, @@ -47754,6 +51761,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceDriverProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceDriverProperties*>( this ); @@ -47764,6 +51772,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceDriverProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceDriverProperties const& ) const = default; #else @@ -47783,6 +51792,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDriverProperties; void* pNext = {}; @@ -47790,12 +51801,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_NAME_SIZE> driverName = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_INFO_SIZE> driverInfo = {}; VULKAN_HPP_NAMESPACE::ConformanceVersion conformanceVersion = {}; + }; static_assert( sizeof( PhysicalDeviceDriverProperties ) == sizeof( VkPhysicalDeviceDriverProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceDriverProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceDriverProperties> + { + using Type = PhysicalDeviceDriverProperties; + }; + struct PhysicalDeviceExclusiveScissorFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 exclusiveScissor_ = {} ) VULKAN_HPP_NOEXCEPT : exclusiveScissor( exclusiveScissor_ ) {} @@ -47829,6 +51849,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceExclusiveScissorFeaturesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>( this ); @@ -47839,6 +51860,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceExclusiveScissorFeaturesNV const& ) const = default; #else @@ -47855,16 +51877,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 exclusiveScissor = {}; + }; static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceExclusiveScissorFeaturesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV> + { + using Type = PhysicalDeviceExclusiveScissorFeaturesNV; + }; + struct PhysicalDeviceExternalBufferInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalBufferInfo; + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( VULKAN_HPP_NAMESPACE::BufferCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::BufferUsageFlags usage_ = {}, VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT @@ -47914,6 +51947,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceExternalBufferInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( this ); @@ -47924,6 +51958,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceExternalBufferInfo const& ) const = default; #else @@ -47942,18 +51977,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::BufferCreateFlags flags = {}; VULKAN_HPP_NAMESPACE::BufferUsageFlags usage = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + }; static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceExternalBufferInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceExternalBufferInfo> + { + using Type = PhysicalDeviceExternalBufferInfo; + }; + struct PhysicalDeviceExternalFenceInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalFenceInfo; + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT : handleType( handleType_ ) {} @@ -47987,6 +52033,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceExternalFenceInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( this ); @@ -47997,6 +52044,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceExternalFenceInfo const& ) const = default; #else @@ -48013,16 +52061,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits::eOpaqueFd; + }; static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceExternalFenceInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceExternalFenceInfo> + { + using Type = PhysicalDeviceExternalFenceInfo; + }; + struct PhysicalDeviceExternalImageFormatInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalImageFormatInfo; + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT : handleType( handleType_ ) {} @@ -48056,6 +52115,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceExternalImageFormatInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>( this ); @@ -48066,6 +52126,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceExternalImageFormatInfo const& ) const = default; #else @@ -48082,16 +52143,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + }; static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceExternalImageFormatInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceExternalImageFormatInfo> + { + using Type = PhysicalDeviceExternalImageFormatInfo; + }; + struct PhysicalDeviceExternalMemoryHostPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalMemoryHostPropertiesEXT( VULKAN_HPP_NAMESPACE::DeviceSize minImportedHostPointerAlignment_ = {} ) VULKAN_HPP_NOEXCEPT : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ ) {} @@ -48113,6 +52185,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>( this ); @@ -48123,6 +52196,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceExternalMemoryHostPropertiesEXT const& ) const = default; #else @@ -48139,16 +52213,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::DeviceSize minImportedHostPointerAlignment = {}; + }; static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceExternalMemoryHostPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT> + { + using Type = PhysicalDeviceExternalMemoryHostPropertiesEXT; + }; + struct PhysicalDeviceExternalSemaphoreInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalSemaphoreInfo; + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT : handleType( handleType_ ) {} @@ -48182,6 +52267,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceExternalSemaphoreInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( this ); @@ -48192,6 +52278,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceExternalSemaphoreInfo const& ) const = default; #else @@ -48208,16 +52295,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; + }; static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceExternalSemaphoreInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceExternalSemaphoreInfo> + { + using Type = PhysicalDeviceExternalSemaphoreInfo; + }; + struct PhysicalDeviceFeatures2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFeatures2; + VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features_ = {} ) VULKAN_HPP_NOEXCEPT : features( features_ ) {} @@ -48245,12 +52343,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - PhysicalDeviceFeatures2 & setFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features_ ) VULKAN_HPP_NOEXCEPT + PhysicalDeviceFeatures2 & setFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & features_ ) VULKAN_HPP_NOEXCEPT { features = features_; return *this; } + operator VkPhysicalDeviceFeatures2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceFeatures2*>( this ); @@ -48261,6 +52360,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceFeatures2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceFeatures2 const& ) const = default; #else @@ -48277,16 +52377,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFeatures2; void* pNext = {}; VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features = {}; + }; static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceFeatures2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceFeatures2> + { + using Type = PhysicalDeviceFeatures2; + }; + struct PhysicalDeviceFloatControlsProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFloatControlsProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceFloatControlsProperties( VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence denormBehaviorIndependence_ = VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence::e32BitOnly, VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence roundingModeIndependence_ = VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence::e32BitOnly, VULKAN_HPP_NAMESPACE::Bool32 shaderSignedZeroInfNanPreserveFloat16_ = {}, @@ -48340,6 +52451,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceFloatControlsProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>( this ); @@ -48350,6 +52462,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceFloatControlsProperties const& ) const = default; #else @@ -48382,6 +52495,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFloatControlsProperties; void* pNext = {}; @@ -48402,12 +52517,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTZFloat16 = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTZFloat32 = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderRoundingModeRTZFloat64 = {}; + }; static_assert( sizeof( PhysicalDeviceFloatControlsProperties ) == sizeof( VkPhysicalDeviceFloatControlsProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceFloatControlsProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceFloatControlsProperties> + { + using Type = PhysicalDeviceFloatControlsProperties; + }; + struct PhysicalDeviceFragmentDensityMapFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMap_ = {}, VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapDynamic_ = {}, VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapNonSubsampledImages_ = {} ) VULKAN_HPP_NOEXCEPT @@ -48433,6 +52557,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>( this ); @@ -48443,6 +52568,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceFragmentDensityMapFeaturesEXT const& ) const = default; #else @@ -48461,18 +52587,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMap = {}; VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapDynamic = {}; VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapNonSubsampledImages = {}; + }; static_assert( sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceFragmentDensityMapFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT> + { + using Type = PhysicalDeviceFragmentDensityMapFeaturesEXT; + }; + struct PhysicalDeviceFragmentDensityMapPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapPropertiesEXT( VULKAN_HPP_NAMESPACE::Extent2D minFragmentDensityTexelSize_ = {}, VULKAN_HPP_NAMESPACE::Extent2D maxFragmentDensityTexelSize_ = {}, VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityInvocations_ = {} ) VULKAN_HPP_NOEXCEPT @@ -48498,6 +52635,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>( this ); @@ -48508,6 +52646,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceFragmentDensityMapPropertiesEXT const& ) const = default; #else @@ -48526,18 +52665,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Extent2D minFragmentDensityTexelSize = {}; VULKAN_HPP_NAMESPACE::Extent2D maxFragmentDensityTexelSize = {}; VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityInvocations = {}; + }; static_assert( sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceFragmentDensityMapPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT> + { + using Type = PhysicalDeviceFragmentDensityMapPropertiesEXT; + }; + struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderBarycentric_ = {} ) VULKAN_HPP_NOEXCEPT : fragmentShaderBarycentric( fragmentShaderBarycentric_ ) {} @@ -48571,6 +52721,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>( this ); @@ -48581,6 +52732,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const& ) const = default; #else @@ -48597,16 +52749,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderBarycentric = {}; + }; static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceFragmentShaderBarycentricFeaturesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV> + { + using Type = PhysicalDeviceFragmentShaderBarycentricFeaturesNV; + }; + struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderSampleInterlock_ = {}, VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderPixelInterlock_ = {}, VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderShadingRateInterlock_ = {} ) VULKAN_HPP_NOEXCEPT @@ -48656,6 +52819,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>( this ); @@ -48666,6 +52830,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const& ) const = default; #else @@ -48684,18 +52849,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderSampleInterlock = {}; VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderPixelInterlock = {}; VULKAN_HPP_NAMESPACE::Bool32 fragmentShaderShadingRateInterlock = {}; + }; static_assert( sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceFragmentShaderInterlockFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT> + { + using Type = PhysicalDeviceFragmentShaderInterlockFeaturesEXT; + }; + struct PhysicalDeviceGroupProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceGroupProperties; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGroupProperties( uint32_t physicalDeviceCount_ = {}, std::array<VULKAN_HPP_NAMESPACE::PhysicalDevice,VK_MAX_DEVICE_GROUP_SIZE> const& physicalDevices_ = {}, VULKAN_HPP_NAMESPACE::Bool32 subsetAllocation_ = {} ) VULKAN_HPP_NOEXCEPT @@ -48721,6 +52897,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceGroupProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceGroupProperties*>( this ); @@ -48731,6 +52908,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceGroupProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceGroupProperties const& ) const = default; #else @@ -48749,18 +52927,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceGroupProperties; void* pNext = {}; uint32_t physicalDeviceCount = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::PhysicalDevice, VK_MAX_DEVICE_GROUP_SIZE> physicalDevices = {}; VULKAN_HPP_NAMESPACE::Bool32 subsetAllocation = {}; + }; static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceGroupProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceGroupProperties> + { + using Type = PhysicalDeviceGroupProperties; + }; + struct PhysicalDeviceHostQueryResetFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceHostQueryResetFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeatures( VULKAN_HPP_NAMESPACE::Bool32 hostQueryReset_ = {} ) VULKAN_HPP_NOEXCEPT : hostQueryReset( hostQueryReset_ ) {} @@ -48794,6 +52983,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceHostQueryResetFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>( this ); @@ -48804,6 +52994,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceHostQueryResetFeatures const& ) const = default; #else @@ -48820,16 +53011,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 hostQueryReset = {}; + }; static_assert( sizeof( PhysicalDeviceHostQueryResetFeatures ) == sizeof( VkPhysicalDeviceHostQueryResetFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceHostQueryResetFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceHostQueryResetFeatures> + { + using Type = PhysicalDeviceHostQueryResetFeatures; + }; + struct PhysicalDeviceIDProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceIdProperties; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIDProperties( std::array<uint8_t,VK_UUID_SIZE> const& deviceUUID_ = {}, std::array<uint8_t,VK_UUID_SIZE> const& driverUUID_ = {}, std::array<uint8_t,VK_LUID_SIZE> const& deviceLUID_ = {}, @@ -48859,6 +53061,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceIDProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceIDProperties*>( this ); @@ -48869,6 +53072,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceIDProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceIDProperties const& ) const = default; #else @@ -48889,6 +53093,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceIdProperties; void* pNext = {}; @@ -48897,12 +53103,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_LUID_SIZE> deviceLUID = {}; uint32_t deviceNodeMask = {}; VULKAN_HPP_NAMESPACE::Bool32 deviceLUIDValid = {}; + }; static_assert( sizeof( PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceIDProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceIdProperties> + { + using Type = PhysicalDeviceIDProperties; + }; + struct PhysicalDeviceImageDrmFormatModifierInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = {}, VULKAN_HPP_NAMESPACE::SharingMode sharingMode_ = VULKAN_HPP_NAMESPACE::SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = {}, @@ -48960,6 +53175,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>( this ); @@ -48970,6 +53186,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceImageDrmFormatModifierInfoEXT const& ) const = default; #else @@ -48989,6 +53206,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT; const void* pNext = {}; @@ -48996,12 +53215,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::SharingMode sharingMode = VULKAN_HPP_NAMESPACE::SharingMode::eExclusive; uint32_t queueFamilyIndexCount = {}; const uint32_t* pQueueFamilyIndices = {}; + }; static_assert( sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) == sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceImageDrmFormatModifierInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT> + { + using Type = PhysicalDeviceImageDrmFormatModifierInfoEXT; + }; + struct PhysicalDeviceImageFormatInfo2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageFormatInfo2; + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, VULKAN_HPP_NAMESPACE::ImageType type_ = VULKAN_HPP_NAMESPACE::ImageType::e1D, VULKAN_HPP_NAMESPACE::ImageTiling tiling_ = VULKAN_HPP_NAMESPACE::ImageTiling::eOptimal, @@ -49067,6 +53295,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceImageFormatInfo2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( this ); @@ -49077,6 +53306,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceImageFormatInfo2 const& ) const = default; #else @@ -49097,6 +53327,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2; const void* pNext = {}; @@ -49105,12 +53337,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ImageTiling tiling = VULKAN_HPP_NAMESPACE::ImageTiling::eOptimal; VULKAN_HPP_NAMESPACE::ImageUsageFlags usage = {}; VULKAN_HPP_NAMESPACE::ImageCreateFlags flags = {}; + }; static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceImageFormatInfo2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceImageFormatInfo2> + { + using Type = PhysicalDeviceImageFormatInfo2; + }; + struct PhysicalDeviceImageViewImageFormatInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( VULKAN_HPP_NAMESPACE::ImageViewType imageViewType_ = VULKAN_HPP_NAMESPACE::ImageViewType::e1D ) VULKAN_HPP_NOEXCEPT : imageViewType( imageViewType_ ) {} @@ -49144,6 +53385,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceImageViewImageFormatInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>( this ); @@ -49154,6 +53396,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceImageViewImageFormatInfoEXT const& ) const = default; #else @@ -49170,16 +53413,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::ImageViewType imageViewType = VULKAN_HPP_NAMESPACE::ImageViewType::e1D; + }; static_assert( sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) == sizeof( VkPhysicalDeviceImageViewImageFormatInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceImageViewImageFormatInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT> + { + using Type = PhysicalDeviceImageViewImageFormatInfoEXT; + }; + struct PhysicalDeviceImagelessFramebufferFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImagelessFramebufferFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeatures( VULKAN_HPP_NAMESPACE::Bool32 imagelessFramebuffer_ = {} ) VULKAN_HPP_NOEXCEPT : imagelessFramebuffer( imagelessFramebuffer_ ) {} @@ -49213,6 +53467,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceImagelessFramebufferFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>( this ); @@ -49223,6 +53478,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceImagelessFramebufferFeatures const& ) const = default; #else @@ -49239,16 +53495,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceImagelessFramebufferFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 imagelessFramebuffer = {}; + }; static_assert( sizeof( PhysicalDeviceImagelessFramebufferFeatures ) == sizeof( VkPhysicalDeviceImagelessFramebufferFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceImagelessFramebufferFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceImagelessFramebufferFeatures> + { + using Type = PhysicalDeviceImagelessFramebufferFeatures; + }; + struct PhysicalDeviceIndexTypeUint8FeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 indexTypeUint8_ = {} ) VULKAN_HPP_NOEXCEPT : indexTypeUint8( indexTypeUint8_ ) {} @@ -49282,6 +53549,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceIndexTypeUint8FeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>( this ); @@ -49292,6 +53560,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceIndexTypeUint8FeaturesEXT const& ) const = default; #else @@ -49308,16 +53577,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 indexTypeUint8 = {}; + }; static_assert( sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceIndexTypeUint8FeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT> + { + using Type = PhysicalDeviceIndexTypeUint8FeaturesEXT; + }; + struct PhysicalDeviceInlineUniformBlockFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 inlineUniformBlock_ = {}, VULKAN_HPP_NAMESPACE::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = {} ) VULKAN_HPP_NOEXCEPT : inlineUniformBlock( inlineUniformBlock_ ) @@ -49359,6 +53639,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceInlineUniformBlockFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>( this ); @@ -49369,6 +53650,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceInlineUniformBlockFeaturesEXT const& ) const = default; #else @@ -49386,17 +53668,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 inlineUniformBlock = {}; VULKAN_HPP_NAMESPACE::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind = {}; + }; static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceInlineUniformBlockFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT> + { + using Type = PhysicalDeviceInlineUniformBlockFeaturesEXT; + }; + struct PhysicalDeviceInlineUniformBlockPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockPropertiesEXT( uint32_t maxInlineUniformBlockSize_ = {}, uint32_t maxPerStageDescriptorInlineUniformBlocks_ = {}, uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ = {}, @@ -49426,6 +53719,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceInlineUniformBlockPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>( this ); @@ -49436,6 +53730,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceInlineUniformBlockPropertiesEXT const& ) const = default; #else @@ -49456,6 +53751,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT; void* pNext = {}; @@ -49464,12 +53761,20 @@ namespace VULKAN_HPP_NAMESPACE uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = {}; uint32_t maxDescriptorSetInlineUniformBlocks = {}; uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks = {}; + }; static_assert( sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceInlineUniformBlockPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT> + { + using Type = PhysicalDeviceInlineUniformBlockPropertiesEXT; + }; + struct PhysicalDeviceLimits { + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLimits( uint32_t maxImageDimension1D_ = {}, uint32_t maxImageDimension2D_ = {}, uint32_t maxImageDimension3D_ = {}, @@ -49695,6 +54000,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceLimits const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceLimits*>( this ); @@ -49705,6 +54011,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceLimits*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceLimits const& ) const = default; #else @@ -49824,6 +54131,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t maxImageDimension1D = {}; uint32_t maxImageDimension2D = {}; @@ -49931,12 +54240,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeviceSize optimalBufferCopyOffsetAlignment = {}; VULKAN_HPP_NAMESPACE::DeviceSize optimalBufferCopyRowPitchAlignment = {}; VULKAN_HPP_NAMESPACE::DeviceSize nonCoherentAtomSize = {}; + }; static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceLimits>::value, "struct wrapper is not a standard layout!" ); struct PhysicalDeviceLineRasterizationFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 rectangularLines_ = {}, VULKAN_HPP_NAMESPACE::Bool32 bresenhamLines_ = {}, VULKAN_HPP_NAMESPACE::Bool32 smoothLines_ = {}, @@ -50010,6 +54322,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceLineRasterizationFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>( this ); @@ -50020,6 +54333,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceLineRasterizationFeaturesEXT const& ) const = default; #else @@ -50041,6 +54355,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT; void* pNext = {}; @@ -50050,12 +54366,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 stippledRectangularLines = {}; VULKAN_HPP_NAMESPACE::Bool32 stippledBresenhamLines = {}; VULKAN_HPP_NAMESPACE::Bool32 stippledSmoothLines = {}; + }; static_assert( sizeof( PhysicalDeviceLineRasterizationFeaturesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceLineRasterizationFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT> + { + using Type = PhysicalDeviceLineRasterizationFeaturesEXT; + }; + struct PhysicalDeviceLineRasterizationPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationPropertiesEXT( uint32_t lineSubPixelPrecisionBits_ = {} ) VULKAN_HPP_NOEXCEPT : lineSubPixelPrecisionBits( lineSubPixelPrecisionBits_ ) {} @@ -50077,6 +54402,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceLineRasterizationPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>( this ); @@ -50087,6 +54413,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceLineRasterizationPropertiesEXT const& ) const = default; #else @@ -50103,16 +54430,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT; void* pNext = {}; uint32_t lineSubPixelPrecisionBits = {}; + }; static_assert( sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceLineRasterizationPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT> + { + using Type = PhysicalDeviceLineRasterizationPropertiesEXT; + }; + struct PhysicalDeviceMaintenance3Properties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance3Properties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance3Properties( uint32_t maxPerSetDescriptors_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize maxMemoryAllocationSize_ = {} ) VULKAN_HPP_NOEXCEPT : maxPerSetDescriptors( maxPerSetDescriptors_ ) @@ -50136,6 +54474,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceMaintenance3Properties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>( this ); @@ -50146,6 +54485,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceMaintenance3Properties const& ) const = default; #else @@ -50163,17 +54503,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties; void* pNext = {}; uint32_t maxPerSetDescriptors = {}; VULKAN_HPP_NAMESPACE::DeviceSize maxMemoryAllocationSize = {}; + }; static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceMaintenance3Properties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceMaintenance3Properties> + { + using Type = PhysicalDeviceMaintenance3Properties; + }; + struct PhysicalDeviceMemoryBudgetPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryBudgetPropertiesEXT( std::array<VULKAN_HPP_NAMESPACE::DeviceSize,VK_MAX_MEMORY_HEAPS> const& heapBudget_ = {}, std::array<VULKAN_HPP_NAMESPACE::DeviceSize,VK_MAX_MEMORY_HEAPS> const& heapUsage_ = {} ) VULKAN_HPP_NOEXCEPT : heapBudget( heapBudget_ ) @@ -50197,6 +54548,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>( this ); @@ -50207,6 +54559,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceMemoryBudgetPropertiesEXT const& ) const = default; #else @@ -50224,17 +54577,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::DeviceSize, VK_MAX_MEMORY_HEAPS> heapBudget = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::DeviceSize, VK_MAX_MEMORY_HEAPS> heapUsage = {}; + }; static_assert( sizeof( PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceMemoryBudgetPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT> + { + using Type = PhysicalDeviceMemoryBudgetPropertiesEXT; + }; + struct PhysicalDeviceMemoryPriorityFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 memoryPriority_ = {} ) VULKAN_HPP_NOEXCEPT : memoryPriority( memoryPriority_ ) {} @@ -50268,6 +54632,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>( this ); @@ -50278,6 +54643,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceMemoryPriorityFeaturesEXT const& ) const = default; #else @@ -50294,16 +54660,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 memoryPriority = {}; + }; static_assert( sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) == sizeof( VkPhysicalDeviceMemoryPriorityFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceMemoryPriorityFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT> + { + using Type = PhysicalDeviceMemoryPriorityFeaturesEXT; + }; + struct PhysicalDeviceMemoryProperties { + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties( uint32_t memoryTypeCount_ = {}, std::array<VULKAN_HPP_NAMESPACE::MemoryType,VK_MAX_MEMORY_TYPES> const& memoryTypes_ = {}, uint32_t memoryHeapCount_ = {}, @@ -50325,6 +54701,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceMemoryProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>( this ); @@ -50335,6 +54712,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceMemoryProperties const& ) const = default; #else @@ -50352,17 +54730,22 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t memoryTypeCount = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::MemoryType, VK_MAX_MEMORY_TYPES> memoryTypes = {}; uint32_t memoryHeapCount = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::MemoryHeap, VK_MAX_MEMORY_HEAPS> memoryHeaps = {}; + }; static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceMemoryProperties>::value, "struct wrapper is not a standard layout!" ); struct PhysicalDeviceMemoryProperties2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryProperties2; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties_ = {} ) VULKAN_HPP_NOEXCEPT : memoryProperties( memoryProperties_ ) {} @@ -50384,6 +54767,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceMemoryProperties2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2*>( this ); @@ -50394,6 +54778,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceMemoryProperties2 const& ) const = default; #else @@ -50410,16 +54795,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2; void* pNext = {}; VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties = {}; + }; static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceMemoryProperties2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceMemoryProperties2> + { + using Type = PhysicalDeviceMemoryProperties2; + }; + struct PhysicalDeviceMeshShaderFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 taskShader_ = {}, VULKAN_HPP_NAMESPACE::Bool32 meshShader_ = {} ) VULKAN_HPP_NOEXCEPT : taskShader( taskShader_ ) @@ -50461,6 +54857,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceMeshShaderFeaturesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>( this ); @@ -50471,6 +54868,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceMeshShaderFeaturesNV const& ) const = default; #else @@ -50488,17 +54886,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 taskShader = {}; VULKAN_HPP_NAMESPACE::Bool32 meshShader = {}; + }; static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceMeshShaderFeaturesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceMeshShaderFeaturesNV> + { + using Type = PhysicalDeviceMeshShaderFeaturesNV; + }; + struct PhysicalDeviceMeshShaderPropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesNV( uint32_t maxDrawMeshTasksCount_ = {}, uint32_t maxTaskWorkGroupInvocations_ = {}, std::array<uint32_t,3> const& maxTaskWorkGroupSize_ = {}, @@ -50544,6 +54953,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceMeshShaderPropertiesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>( this ); @@ -50554,6 +54964,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceMeshShaderPropertiesNV const& ) const = default; #else @@ -50582,6 +54993,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV; void* pNext = {}; @@ -50598,12 +55011,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t maxMeshMultiviewViewCount = {}; uint32_t meshOutputPerVertexGranularity = {}; uint32_t meshOutputPerPrimitiveGranularity = {}; + }; static_assert( sizeof( PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceMeshShaderPropertiesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceMeshShaderPropertiesNV> + { + using Type = PhysicalDeviceMeshShaderPropertiesNV; + }; + struct PhysicalDeviceMultiviewFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( VULKAN_HPP_NAMESPACE::Bool32 multiview_ = {}, VULKAN_HPP_NAMESPACE::Bool32 multiviewGeometryShader_ = {}, VULKAN_HPP_NAMESPACE::Bool32 multiviewTessellationShader_ = {} ) VULKAN_HPP_NOEXCEPT @@ -50653,6 +55075,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceMultiviewFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>( this ); @@ -50663,6 +55086,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceMultiviewFeatures const& ) const = default; #else @@ -50681,18 +55105,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 multiview = {}; VULKAN_HPP_NAMESPACE::Bool32 multiviewGeometryShader = {}; VULKAN_HPP_NAMESPACE::Bool32 multiviewTessellationShader = {}; + }; static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceMultiviewFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceMultiviewFeatures> + { + using Type = PhysicalDeviceMultiviewFeatures; + }; + struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VULKAN_HPP_NAMESPACE::Bool32 perViewPositionAllComponents_ = {} ) VULKAN_HPP_NOEXCEPT : perViewPositionAllComponents( perViewPositionAllComponents_ ) {} @@ -50714,6 +55149,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>( this ); @@ -50724,6 +55160,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& ) const = default; #else @@ -50740,16 +55177,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 perViewPositionAllComponents = {}; + }; static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX> + { + using Type = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + }; + struct PhysicalDeviceMultiviewProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewProperties( uint32_t maxMultiviewViewCount_ = {}, uint32_t maxMultiviewInstanceIndex_ = {} ) VULKAN_HPP_NOEXCEPT : maxMultiviewViewCount( maxMultiviewViewCount_ ) @@ -50773,6 +55221,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceMultiviewProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>( this ); @@ -50783,6 +55232,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceMultiviewProperties const& ) const = default; #else @@ -50800,17 +55250,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties; void* pNext = {}; uint32_t maxMultiviewViewCount = {}; uint32_t maxMultiviewInstanceIndex = {}; + }; static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceMultiviewProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceMultiviewProperties> + { + using Type = PhysicalDeviceMultiviewProperties; + }; + struct PhysicalDevicePCIBusInfoPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDevicePCIBusInfoPropertiesEXT( uint32_t pciDomain_ = {}, uint32_t pciBus_ = {}, uint32_t pciDevice_ = {}, @@ -50838,6 +55299,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDevicePCIBusInfoPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>( this ); @@ -50848,6 +55310,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDevicePCIBusInfoPropertiesEXT const& ) const = default; #else @@ -50867,6 +55330,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT; void* pNext = {}; @@ -50874,12 +55339,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t pciBus = {}; uint32_t pciDevice = {}; uint32_t pciFunction = {}; + }; static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDevicePCIBusInfoPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDevicePciBusInfoPropertiesEXT> + { + using Type = PhysicalDevicePCIBusInfoPropertiesEXT; + }; + struct PhysicalDevicePerformanceQueryFeaturesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR; + VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 performanceCounterQueryPools_ = {}, VULKAN_HPP_NAMESPACE::Bool32 performanceCounterMultipleQueryPools_ = {} ) VULKAN_HPP_NOEXCEPT : performanceCounterQueryPools( performanceCounterQueryPools_ ) @@ -50921,6 +55395,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDevicePerformanceQueryFeaturesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>( this ); @@ -50931,6 +55406,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDevicePerformanceQueryFeaturesKHR const& ) const = default; #else @@ -50948,17 +55424,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 performanceCounterQueryPools = {}; VULKAN_HPP_NAMESPACE::Bool32 performanceCounterMultipleQueryPools = {}; + }; static_assert( sizeof( PhysicalDevicePerformanceQueryFeaturesKHR ) == sizeof( VkPhysicalDevicePerformanceQueryFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDevicePerformanceQueryFeaturesKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR> + { + using Type = PhysicalDevicePerformanceQueryFeaturesKHR; + }; + struct PhysicalDevicePerformanceQueryPropertiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR; + VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryPropertiesKHR( VULKAN_HPP_NAMESPACE::Bool32 allowCommandBufferQueryCopies_ = {} ) VULKAN_HPP_NOEXCEPT : allowCommandBufferQueryCopies( allowCommandBufferQueryCopies_ ) {} @@ -50980,6 +55467,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDevicePerformanceQueryPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>( this ); @@ -50990,6 +55478,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDevicePerformanceQueryPropertiesKHR const& ) const = default; #else @@ -51006,16 +55495,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 allowCommandBufferQueryCopies = {}; + }; static_assert( sizeof( PhysicalDevicePerformanceQueryPropertiesKHR ) == sizeof( VkPhysicalDevicePerformanceQueryPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDevicePerformanceQueryPropertiesKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR> + { + using Type = PhysicalDevicePerformanceQueryPropertiesKHR; + }; + struct PhysicalDevicePipelineCreationCacheControlFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineCreationCacheControlFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineCreationCacheControlFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 pipelineCreationCacheControl_ = {} ) VULKAN_HPP_NOEXCEPT : pipelineCreationCacheControl( pipelineCreationCacheControl_ ) {} @@ -51049,6 +55549,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>( this ); @@ -51059,6 +55560,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const& ) const = default; #else @@ -51075,16 +55577,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePipelineCreationCacheControlFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 pipelineCreationCacheControl = {}; + }; static_assert( sizeof( PhysicalDevicePipelineCreationCacheControlFeaturesEXT ) == sizeof( VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDevicePipelineCreationCacheControlFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDevicePipelineCreationCacheControlFeaturesEXT> + { + using Type = PhysicalDevicePipelineCreationCacheControlFeaturesEXT; + }; + struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 pipelineExecutableInfo_ = {} ) VULKAN_HPP_NOEXCEPT : pipelineExecutableInfo( pipelineExecutableInfo_ ) {} @@ -51118,6 +55631,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>( this ); @@ -51128,6 +55642,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const& ) const = default; #else @@ -51144,16 +55659,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 pipelineExecutableInfo = {}; + }; static_assert( sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR> + { + using Type = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + }; + struct PhysicalDevicePointClippingProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePointClippingProperties; + VULKAN_HPP_CONSTEXPR PhysicalDevicePointClippingProperties( VULKAN_HPP_NAMESPACE::PointClippingBehavior pointClippingBehavior_ = VULKAN_HPP_NAMESPACE::PointClippingBehavior::eAllClipPlanes ) VULKAN_HPP_NOEXCEPT : pointClippingBehavior( pointClippingBehavior_ ) {} @@ -51175,6 +55701,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDevicePointClippingProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>( this ); @@ -51185,6 +55712,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDevicePointClippingProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDevicePointClippingProperties const& ) const = default; #else @@ -51201,16 +55729,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePointClippingProperties; void* pNext = {}; VULKAN_HPP_NAMESPACE::PointClippingBehavior pointClippingBehavior = VULKAN_HPP_NAMESPACE::PointClippingBehavior::eAllClipPlanes; + }; static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDevicePointClippingProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDevicePointClippingProperties> + { + using Type = PhysicalDevicePointClippingProperties; + }; + struct PhysicalDeviceSparseProperties { + VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseProperties( VULKAN_HPP_NAMESPACE::Bool32 residencyStandard2DBlockShape_ = {}, VULKAN_HPP_NAMESPACE::Bool32 residencyStandard2DMultisampleBlockShape_ = {}, VULKAN_HPP_NAMESPACE::Bool32 residencyStandard3DBlockShape_ = {}, @@ -51234,6 +55772,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceSparseProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceSparseProperties*>( this ); @@ -51244,6 +55783,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceSparseProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceSparseProperties const& ) const = default; #else @@ -51262,18 +55802,22 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Bool32 residencyStandard2DBlockShape = {}; VULKAN_HPP_NAMESPACE::Bool32 residencyStandard2DMultisampleBlockShape = {}; VULKAN_HPP_NAMESPACE::Bool32 residencyStandard3DBlockShape = {}; VULKAN_HPP_NAMESPACE::Bool32 residencyAlignedMipSize = {}; VULKAN_HPP_NAMESPACE::Bool32 residencyNonResidentStrict = {}; + }; static_assert( sizeof( PhysicalDeviceSparseProperties ) == sizeof( VkPhysicalDeviceSparseProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceSparseProperties>::value, "struct wrapper is not a standard layout!" ); struct PhysicalDeviceProperties { + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties( uint32_t apiVersion_ = {}, uint32_t driverVersion_ = {}, uint32_t vendorID_ = {}, @@ -51305,6 +55849,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceProperties*>( this ); @@ -51315,6 +55860,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceProperties const& ) const = default; #else @@ -51337,6 +55883,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t apiVersion = {}; uint32_t driverVersion = {}; @@ -51347,12 +55895,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> pipelineCacheUUID = {}; VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits limits = {}; VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties sparseProperties = {}; + }; static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceProperties>::value, "struct wrapper is not a standard layout!" ); struct PhysicalDeviceProperties2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProperties2; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties_ = {} ) VULKAN_HPP_NOEXCEPT : properties( properties_ ) {} @@ -51374,6 +55925,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceProperties2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceProperties2*>( this ); @@ -51384,6 +55936,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceProperties2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceProperties2 const& ) const = default; #else @@ -51400,16 +55953,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceProperties2; void* pNext = {}; VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties = {}; + }; static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceProperties2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceProperties2> + { + using Type = PhysicalDeviceProperties2; + }; + struct PhysicalDeviceProtectedMemoryFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProtectedMemoryFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( VULKAN_HPP_NAMESPACE::Bool32 protectedMemory_ = {} ) VULKAN_HPP_NOEXCEPT : protectedMemory( protectedMemory_ ) {} @@ -51443,6 +56007,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceProtectedMemoryFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>( this ); @@ -51453,6 +56018,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceProtectedMemoryFeatures const& ) const = default; #else @@ -51469,16 +56035,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 protectedMemory = {}; + }; static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceProtectedMemoryFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceProtectedMemoryFeatures> + { + using Type = PhysicalDeviceProtectedMemoryFeatures; + }; + struct PhysicalDeviceProtectedMemoryProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProtectedMemoryProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryProperties( VULKAN_HPP_NAMESPACE::Bool32 protectedNoFault_ = {} ) VULKAN_HPP_NOEXCEPT : protectedNoFault( protectedNoFault_ ) {} @@ -51500,6 +56077,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceProtectedMemoryProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>( this ); @@ -51510,6 +56088,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceProtectedMemoryProperties const& ) const = default; #else @@ -51526,16 +56105,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 protectedNoFault = {}; + }; static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceProtectedMemoryProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceProtectedMemoryProperties> + { + using Type = PhysicalDeviceProtectedMemoryProperties; + }; + struct PhysicalDevicePushDescriptorPropertiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR; + VULKAN_HPP_CONSTEXPR PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = {} ) VULKAN_HPP_NOEXCEPT : maxPushDescriptors( maxPushDescriptors_ ) {} @@ -51557,6 +56147,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDevicePushDescriptorPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>( this ); @@ -51567,6 +56158,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDevicePushDescriptorPropertiesKHR const& ) const = default; #else @@ -51583,17 +56175,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR; void* pNext = {}; uint32_t maxPushDescriptors = {}; + }; static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDevicePushDescriptorPropertiesKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDevicePushDescriptorPropertiesKHR> + { + using Type = PhysicalDevicePushDescriptorPropertiesKHR; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct PhysicalDeviceRayTracingFeaturesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingFeaturesKHR; + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 rayTracing_ = {}, VULKAN_HPP_NAMESPACE::Bool32 rayTracingShaderGroupHandleCaptureReplay_ = {}, VULKAN_HPP_NAMESPACE::Bool32 rayTracingShaderGroupHandleCaptureReplayMixed_ = {}, @@ -51691,6 +56294,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceRayTracingFeaturesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceRayTracingFeaturesKHR*>( this ); @@ -51701,6 +56305,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceRayTracingFeaturesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceRayTracingFeaturesKHR const& ) const = default; #else @@ -51725,6 +56330,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRayTracingFeaturesKHR; void* pNext = {}; @@ -51737,14 +56344,23 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 rayTracingHostAccelerationStructureCommands = {}; VULKAN_HPP_NAMESPACE::Bool32 rayQuery = {}; VULKAN_HPP_NAMESPACE::Bool32 rayTracingPrimitiveCulling = {}; + }; static_assert( sizeof( PhysicalDeviceRayTracingFeaturesKHR ) == sizeof( VkPhysicalDeviceRayTracingFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceRayTracingFeaturesKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceRayTracingFeaturesKHR> + { + using Type = PhysicalDeviceRayTracingFeaturesKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct PhysicalDeviceRayTracingPropertiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingPropertiesKHR; + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPropertiesKHR( uint32_t shaderGroupHandleSize_ = {}, uint32_t maxRecursionDepth_ = {}, uint32_t maxShaderGroupStride_ = {}, @@ -51782,6 +56398,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceRayTracingPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesKHR*>( this ); @@ -51792,6 +56409,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceRayTracingPropertiesKHR const& ) const = default; #else @@ -51816,6 +56434,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesKHR; void* pNext = {}; @@ -51828,13 +56448,22 @@ namespace VULKAN_HPP_NAMESPACE uint64_t maxPrimitiveCount = {}; uint32_t maxDescriptorSetAccelerationStructures = {}; uint32_t shaderGroupHandleCaptureReplaySize = {}; + }; static_assert( sizeof( PhysicalDeviceRayTracingPropertiesKHR ) == sizeof( VkPhysicalDeviceRayTracingPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceRayTracingPropertiesKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceRayTracingPropertiesKHR> + { + using Type = PhysicalDeviceRayTracingPropertiesKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct PhysicalDeviceRayTracingPropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingPropertiesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPropertiesNV( uint32_t shaderGroupHandleSize_ = {}, uint32_t maxRecursionDepth_ = {}, uint32_t maxShaderGroupStride_ = {}, @@ -51870,6 +56499,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceRayTracingPropertiesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>( this ); @@ -51880,6 +56510,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceRayTracingPropertiesNV const& ) const = default; #else @@ -51903,6 +56534,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV; void* pNext = {}; @@ -51914,12 +56547,21 @@ namespace VULKAN_HPP_NAMESPACE uint64_t maxInstanceCount = {}; uint64_t maxTriangleCount = {}; uint32_t maxDescriptorSetAccelerationStructures = {}; + }; static_assert( sizeof( PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceRayTracingPropertiesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceRayTracingPropertiesNV> + { + using Type = PhysicalDeviceRayTracingPropertiesNV; + }; + struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTest_ = {} ) VULKAN_HPP_NOEXCEPT : representativeFragmentTest( representativeFragmentTest_ ) {} @@ -51953,6 +56595,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>( this ); @@ -51963,6 +56606,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const& ) const = default; #else @@ -51979,16 +56623,203 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTest = {}; + }; static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceRepresentativeFragmentTestFeaturesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV> + { + using Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNV; + }; + + struct PhysicalDeviceRobustness2FeaturesEXT + { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2FeaturesEXT; + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 nullDescriptor_ = {} ) VULKAN_HPP_NOEXCEPT + : robustBufferAccess2( robustBufferAccess2_ ) + , robustImageAccess2( robustImageAccess2_ ) + , nullDescriptor( nullDescriptor_ ) + {} + + PhysicalDeviceRobustness2FeaturesEXT & operator=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceRobustness2FeaturesEXT ) - offsetof( PhysicalDeviceRobustness2FeaturesEXT, pNext ) ); + return *this; + } + + PhysicalDeviceRobustness2FeaturesEXT( VkPhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } + + PhysicalDeviceRobustness2FeaturesEXT& operator=( VkPhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const *>(&rhs); + return *this; + } + + PhysicalDeviceRobustness2FeaturesEXT & setPNext( void* pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceRobustness2FeaturesEXT & setRobustBufferAccess2( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2_ ) VULKAN_HPP_NOEXCEPT + { + robustBufferAccess2 = robustBufferAccess2_; + return *this; + } + + PhysicalDeviceRobustness2FeaturesEXT & setRobustImageAccess2( VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2_ ) VULKAN_HPP_NOEXCEPT + { + robustImageAccess2 = robustImageAccess2_; + return *this; + } + + PhysicalDeviceRobustness2FeaturesEXT & setNullDescriptor( VULKAN_HPP_NAMESPACE::Bool32 nullDescriptor_ ) VULKAN_HPP_NOEXCEPT + { + nullDescriptor = nullDescriptor_; + return *this; + } + + + operator VkPhysicalDeviceRobustness2FeaturesEXT const&() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>( this ); + } + + operator VkPhysicalDeviceRobustness2FeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>( this ); + } + + +#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) + auto operator<=>( PhysicalDeviceRobustness2FeaturesEXT const& ) const = default; +#else + bool operator==( PhysicalDeviceRobustness2FeaturesEXT const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( robustBufferAccess2 == rhs.robustBufferAccess2 ) + && ( robustImageAccess2 == rhs.robustImageAccess2 ) + && ( nullDescriptor == rhs.nullDescriptor ); + } + + bool operator!=( PhysicalDeviceRobustness2FeaturesEXT const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + + + public: + const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRobustness2FeaturesEXT; + void* pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2 = {}; + VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2 = {}; + VULKAN_HPP_NAMESPACE::Bool32 nullDescriptor = {}; + + }; + static_assert( sizeof( PhysicalDeviceRobustness2FeaturesEXT ) == sizeof( VkPhysicalDeviceRobustness2FeaturesEXT ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout<PhysicalDeviceRobustness2FeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceRobustness2FeaturesEXT> + { + using Type = PhysicalDeviceRobustness2FeaturesEXT; + }; + + struct PhysicalDeviceRobustness2PropertiesEXT + { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2PropertiesEXT; + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesEXT( VULKAN_HPP_NAMESPACE::DeviceSize robustStorageBufferAccessSizeAlignment_ = {}, + VULKAN_HPP_NAMESPACE::DeviceSize robustUniformBufferAccessSizeAlignment_ = {} ) VULKAN_HPP_NOEXCEPT + : robustStorageBufferAccessSizeAlignment( robustStorageBufferAccessSizeAlignment_ ) + , robustUniformBufferAccessSizeAlignment( robustUniformBufferAccessSizeAlignment_ ) + {} + + PhysicalDeviceRobustness2PropertiesEXT & operator=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceRobustness2PropertiesEXT ) - offsetof( PhysicalDeviceRobustness2PropertiesEXT, pNext ) ); + return *this; + } + + PhysicalDeviceRobustness2PropertiesEXT( VkPhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } + + PhysicalDeviceRobustness2PropertiesEXT& operator=( VkPhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const *>(&rhs); + return *this; + } + + + operator VkPhysicalDeviceRobustness2PropertiesEXT const&() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>( this ); + } + + operator VkPhysicalDeviceRobustness2PropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>( this ); + } + + +#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) + auto operator<=>( PhysicalDeviceRobustness2PropertiesEXT const& ) const = default; +#else + bool operator==( PhysicalDeviceRobustness2PropertiesEXT const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( robustStorageBufferAccessSizeAlignment == rhs.robustStorageBufferAccessSizeAlignment ) + && ( robustUniformBufferAccessSizeAlignment == rhs.robustUniformBufferAccessSizeAlignment ); + } + + bool operator!=( PhysicalDeviceRobustness2PropertiesEXT const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + + + public: + const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRobustness2PropertiesEXT; + void* pNext = {}; + VULKAN_HPP_NAMESPACE::DeviceSize robustStorageBufferAccessSizeAlignment = {}; + VULKAN_HPP_NAMESPACE::DeviceSize robustUniformBufferAccessSizeAlignment = {}; + + }; + static_assert( sizeof( PhysicalDeviceRobustness2PropertiesEXT ) == sizeof( VkPhysicalDeviceRobustness2PropertiesEXT ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout<PhysicalDeviceRobustness2PropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceRobustness2PropertiesEXT> + { + using Type = PhysicalDeviceRobustness2PropertiesEXT; + }; + struct PhysicalDeviceSampleLocationsPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSampleLocationsPropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlags sampleLocationSampleCounts_ = {}, VULKAN_HPP_NAMESPACE::Extent2D maxSampleLocationGridSize_ = {}, std::array<float,2> const& sampleLocationCoordinateRange_ = {}, @@ -52018,6 +56849,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceSampleLocationsPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>( this ); @@ -52028,6 +56860,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceSampleLocationsPropertiesEXT const& ) const = default; #else @@ -52048,6 +56881,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; void* pNext = {}; @@ -52056,12 +56891,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> sampleLocationCoordinateRange = {}; uint32_t sampleLocationSubPixelBits = {}; VULKAN_HPP_NAMESPACE::Bool32 variableSampleLocations = {}; + }; static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceSampleLocationsPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT> + { + using Type = PhysicalDeviceSampleLocationsPropertiesEXT; + }; + struct PhysicalDeviceSamplerFilterMinmaxProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerFilterMinmaxProperties( VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxSingleComponentFormats_ = {}, VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxImageComponentMapping_ = {} ) VULKAN_HPP_NOEXCEPT : filterMinmaxSingleComponentFormats( filterMinmaxSingleComponentFormats_ ) @@ -52085,6 +56929,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceSamplerFilterMinmaxProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>( this ); @@ -52095,6 +56940,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceSamplerFilterMinmaxProperties const& ) const = default; #else @@ -52112,17 +56958,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxSingleComponentFormats = {}; VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxImageComponentMapping = {}; + }; static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxProperties ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceSamplerFilterMinmaxProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties> + { + using Type = PhysicalDeviceSamplerFilterMinmaxProperties; + }; + struct PhysicalDeviceSamplerYcbcrConversionFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( VULKAN_HPP_NAMESPACE::Bool32 samplerYcbcrConversion_ = {} ) VULKAN_HPP_NOEXCEPT : samplerYcbcrConversion( samplerYcbcrConversion_ ) {} @@ -52156,6 +57013,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>( this ); @@ -52166,6 +57024,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceSamplerYcbcrConversionFeatures const& ) const = default; #else @@ -52182,16 +57041,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 samplerYcbcrConversion = {}; + }; static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceSamplerYcbcrConversionFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures> + { + using Type = PhysicalDeviceSamplerYcbcrConversionFeatures; + }; + struct PhysicalDeviceScalarBlockLayoutFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceScalarBlockLayoutFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeatures( VULKAN_HPP_NAMESPACE::Bool32 scalarBlockLayout_ = {} ) VULKAN_HPP_NOEXCEPT : scalarBlockLayout( scalarBlockLayout_ ) {} @@ -52225,6 +57095,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceScalarBlockLayoutFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>( this ); @@ -52235,6 +57106,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceScalarBlockLayoutFeatures const& ) const = default; #else @@ -52251,16 +57123,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 scalarBlockLayout = {}; + }; static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeatures ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceScalarBlockLayoutFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceScalarBlockLayoutFeatures> + { + using Type = PhysicalDeviceScalarBlockLayoutFeatures; + }; + struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSeparateDepthStencilLayoutsFeatures( VULKAN_HPP_NAMESPACE::Bool32 separateDepthStencilLayouts_ = {} ) VULKAN_HPP_NOEXCEPT : separateDepthStencilLayouts( separateDepthStencilLayouts_ ) {} @@ -52294,6 +57177,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>( this ); @@ -52304,6 +57188,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const& ) const = default; #else @@ -52320,16 +57205,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 separateDepthStencilLayouts = {}; + }; static_assert( sizeof( PhysicalDeviceSeparateDepthStencilLayoutsFeatures ) == sizeof( VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceSeparateDepthStencilLayoutsFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures> + { + using Type = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; + }; + struct PhysicalDeviceShaderAtomicInt64Features { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderAtomicInt64Features; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64Features( VULKAN_HPP_NAMESPACE::Bool32 shaderBufferInt64Atomics_ = {}, VULKAN_HPP_NAMESPACE::Bool32 shaderSharedInt64Atomics_ = {} ) VULKAN_HPP_NOEXCEPT : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ ) @@ -52371,6 +57267,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceShaderAtomicInt64Features const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>( this ); @@ -52381,6 +57278,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceShaderAtomicInt64Features const& ) const = default; #else @@ -52398,17 +57296,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64Features; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderBufferInt64Atomics = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderSharedInt64Atomics = {}; + }; static_assert( sizeof( PhysicalDeviceShaderAtomicInt64Features ) == sizeof( VkPhysicalDeviceShaderAtomicInt64Features ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceShaderAtomicInt64Features>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceShaderAtomicInt64Features> + { + using Type = PhysicalDeviceShaderAtomicInt64Features; + }; + struct PhysicalDeviceShaderClockFeaturesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 shaderSubgroupClock_ = {}, VULKAN_HPP_NAMESPACE::Bool32 shaderDeviceClock_ = {} ) VULKAN_HPP_NOEXCEPT : shaderSubgroupClock( shaderSubgroupClock_ ) @@ -52450,6 +57359,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceShaderClockFeaturesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>( this ); @@ -52460,6 +57370,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceShaderClockFeaturesKHR const& ) const = default; #else @@ -52477,17 +57388,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderSubgroupClock = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderDeviceClock = {}; + }; static_assert( sizeof( PhysicalDeviceShaderClockFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderClockFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceShaderClockFeaturesKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceShaderClockFeaturesKHR> + { + using Type = PhysicalDeviceShaderClockFeaturesKHR; + }; + struct PhysicalDeviceShaderCoreProperties2AMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreProperties2AMD( VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD shaderCoreFeatures_ = {}, uint32_t activeComputeUnitCount_ = {} ) VULKAN_HPP_NOEXCEPT : shaderCoreFeatures( shaderCoreFeatures_ ) @@ -52511,6 +57433,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceShaderCoreProperties2AMD const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>( this ); @@ -52521,6 +57444,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceShaderCoreProperties2AMD const& ) const = default; #else @@ -52538,17 +57462,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD; void* pNext = {}; VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD shaderCoreFeatures = {}; uint32_t activeComputeUnitCount = {}; + }; static_assert( sizeof( PhysicalDeviceShaderCoreProperties2AMD ) == sizeof( VkPhysicalDeviceShaderCoreProperties2AMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceShaderCoreProperties2AMD>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceShaderCoreProperties2AMD> + { + using Type = PhysicalDeviceShaderCoreProperties2AMD; + }; + struct PhysicalDeviceShaderCorePropertiesAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesAMD( uint32_t shaderEngineCount_ = {}, uint32_t shaderArraysPerEngineCount_ = {}, uint32_t computeUnitsPerShaderArray_ = {}, @@ -52596,6 +57531,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceShaderCorePropertiesAMD const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>( this ); @@ -52606,6 +57542,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceShaderCorePropertiesAMD const& ) const = default; #else @@ -52635,6 +57572,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD; void* pNext = {}; @@ -52652,12 +57591,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t minVgprAllocation = {}; uint32_t maxVgprAllocation = {}; uint32_t vgprAllocationGranularity = {}; + }; static_assert( sizeof( PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceShaderCorePropertiesAMD>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceShaderCorePropertiesAMD> + { + using Type = PhysicalDeviceShaderCorePropertiesAMD; + }; + struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 shaderDemoteToHelperInvocation_ = {} ) VULKAN_HPP_NOEXCEPT : shaderDemoteToHelperInvocation( shaderDemoteToHelperInvocation_ ) {} @@ -52691,6 +57639,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>( this ); @@ -52701,6 +57650,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const& ) const = default; #else @@ -52717,16 +57667,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderDemoteToHelperInvocation = {}; + }; static_assert( sizeof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT> + { + using Type = PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; + }; + struct PhysicalDeviceShaderDrawParametersFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( VULKAN_HPP_NAMESPACE::Bool32 shaderDrawParameters_ = {} ) VULKAN_HPP_NOEXCEPT : shaderDrawParameters( shaderDrawParameters_ ) {} @@ -52760,6 +57721,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceShaderDrawParametersFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>( this ); @@ -52770,6 +57732,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceShaderDrawParametersFeatures const& ) const = default; #else @@ -52786,16 +57749,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderDrawParameters = {}; + }; static_assert( sizeof( PhysicalDeviceShaderDrawParametersFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParametersFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceShaderDrawParametersFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceShaderDrawParametersFeatures> + { + using Type = PhysicalDeviceShaderDrawParametersFeatures; + }; + struct PhysicalDeviceShaderFloat16Int8Features { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderFloat16Int8Features; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8Features( VULKAN_HPP_NAMESPACE::Bool32 shaderFloat16_ = {}, VULKAN_HPP_NAMESPACE::Bool32 shaderInt8_ = {} ) VULKAN_HPP_NOEXCEPT : shaderFloat16( shaderFloat16_ ) @@ -52837,6 +57811,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceShaderFloat16Int8Features const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>( this ); @@ -52847,6 +57822,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceShaderFloat16Int8Features const& ) const = default; #else @@ -52864,17 +57840,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderFloat16Int8Features; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderFloat16 = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderInt8 = {}; + }; static_assert( sizeof( PhysicalDeviceShaderFloat16Int8Features ) == sizeof( VkPhysicalDeviceShaderFloat16Int8Features ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceShaderFloat16Int8Features>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceShaderFloat16Int8Features> + { + using Type = PhysicalDeviceShaderFloat16Int8Features; + }; + struct PhysicalDeviceShaderImageFootprintFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 imageFootprint_ = {} ) VULKAN_HPP_NOEXCEPT : imageFootprint( imageFootprint_ ) {} @@ -52908,6 +57895,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>( this ); @@ -52918,6 +57906,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceShaderImageFootprintFeaturesNV const& ) const = default; #else @@ -52934,16 +57923,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 imageFootprint = {}; + }; static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceShaderImageFootprintFeaturesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV> + { + using Type = PhysicalDeviceShaderImageFootprintFeaturesNV; + }; + struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VULKAN_HPP_NAMESPACE::Bool32 shaderIntegerFunctions2_ = {} ) VULKAN_HPP_NOEXCEPT : shaderIntegerFunctions2( shaderIntegerFunctions2_ ) {} @@ -52977,6 +57977,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>( this ); @@ -52987,6 +57988,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const& ) const = default; #else @@ -53003,16 +58005,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderIntegerFunctions2 = {}; + }; static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL> + { + using Type = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + }; + struct PhysicalDeviceShaderSMBuiltinsFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 shaderSMBuiltins_ = {} ) VULKAN_HPP_NOEXCEPT : shaderSMBuiltins( shaderSMBuiltins_ ) {} @@ -53046,6 +58059,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>( this ); @@ -53056,6 +58070,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceShaderSMBuiltinsFeaturesNV const& ) const = default; #else @@ -53072,16 +58087,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderSMBuiltins = {}; + }; static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceShaderSMBuiltinsFeaturesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV> + { + using Type = PhysicalDeviceShaderSMBuiltinsFeaturesNV; + }; + struct PhysicalDeviceShaderSMBuiltinsPropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsPropertiesNV( uint32_t shaderSMCount_ = {}, uint32_t shaderWarpsPerSM_ = {} ) VULKAN_HPP_NOEXCEPT : shaderSMCount( shaderSMCount_ ) @@ -53105,6 +58131,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>( this ); @@ -53115,6 +58142,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceShaderSMBuiltinsPropertiesNV const& ) const = default; #else @@ -53132,17 +58160,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV; void* pNext = {}; uint32_t shaderSMCount = {}; uint32_t shaderWarpsPerSM = {}; + }; static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsPropertiesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceShaderSMBuiltinsPropertiesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV> + { + using Type = PhysicalDeviceShaderSMBuiltinsPropertiesNV; + }; + struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeatures( VULKAN_HPP_NAMESPACE::Bool32 shaderSubgroupExtendedTypes_ = {} ) VULKAN_HPP_NOEXCEPT : shaderSubgroupExtendedTypes( shaderSubgroupExtendedTypes_ ) {} @@ -53176,6 +58215,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>( this ); @@ -53186,6 +58226,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const& ) const = default; #else @@ -53202,16 +58243,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderSubgroupExtendedTypes = {}; + }; static_assert( sizeof( PhysicalDeviceShaderSubgroupExtendedTypesFeatures ) == sizeof( VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceShaderSubgroupExtendedTypesFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures> + { + using Type = PhysicalDeviceShaderSubgroupExtendedTypesFeatures; + }; + struct PhysicalDeviceShadingRateImageFeaturesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImage_ = {}, VULKAN_HPP_NAMESPACE::Bool32 shadingRateCoarseSampleOrder_ = {} ) VULKAN_HPP_NOEXCEPT : shadingRateImage( shadingRateImage_ ) @@ -53253,6 +58305,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceShadingRateImageFeaturesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>( this ); @@ -53263,6 +58316,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceShadingRateImageFeaturesNV const& ) const = default; #else @@ -53280,17 +58334,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 shadingRateImage = {}; VULKAN_HPP_NAMESPACE::Bool32 shadingRateCoarseSampleOrder = {}; + }; static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceShadingRateImageFeaturesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceShadingRateImageFeaturesNV> + { + using Type = PhysicalDeviceShadingRateImageFeaturesNV; + }; + struct PhysicalDeviceShadingRateImagePropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV; + VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImagePropertiesNV( VULKAN_HPP_NAMESPACE::Extent2D shadingRateTexelSize_ = {}, uint32_t shadingRatePaletteSize_ = {}, uint32_t shadingRateMaxCoarseSamples_ = {} ) VULKAN_HPP_NOEXCEPT @@ -53316,6 +58381,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceShadingRateImagePropertiesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>( this ); @@ -53326,6 +58392,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceShadingRateImagePropertiesNV const& ) const = default; #else @@ -53344,18 +58411,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::Extent2D shadingRateTexelSize = {}; uint32_t shadingRatePaletteSize = {}; uint32_t shadingRateMaxCoarseSamples = {}; + }; static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceShadingRateImagePropertiesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceShadingRateImagePropertiesNV> + { + using Type = PhysicalDeviceShadingRateImagePropertiesNV; + }; + struct PhysicalDeviceSparseImageFormatInfo2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSparseImageFormatInfo2; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, VULKAN_HPP_NAMESPACE::ImageType type_ = VULKAN_HPP_NAMESPACE::ImageType::e1D, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples_ = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1, @@ -53421,6 +58499,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceSparseImageFormatInfo2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( this ); @@ -53431,6 +58510,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceSparseImageFormatInfo2 const& ) const = default; #else @@ -53451,6 +58531,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2; const void* pNext = {}; @@ -53459,12 +58541,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples = VULKAN_HPP_NAMESPACE::SampleCountFlagBits::e1; VULKAN_HPP_NAMESPACE::ImageUsageFlags usage = {}; VULKAN_HPP_NAMESPACE::ImageTiling tiling = VULKAN_HPP_NAMESPACE::ImageTiling::eOptimal; + }; static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceSparseImageFormatInfo2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceSparseImageFormatInfo2> + { + using Type = PhysicalDeviceSparseImageFormatInfo2; + }; + struct PhysicalDeviceSubgroupProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubgroupProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupProperties( uint32_t subgroupSize_ = {}, VULKAN_HPP_NAMESPACE::ShaderStageFlags supportedStages_ = {}, VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags supportedOperations_ = {}, @@ -53492,6 +58583,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceSubgroupProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>( this ); @@ -53502,6 +58594,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceSubgroupProperties const& ) const = default; #else @@ -53521,6 +58614,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties; void* pNext = {}; @@ -53528,12 +58623,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ShaderStageFlags supportedStages = {}; VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags supportedOperations = {}; VULKAN_HPP_NAMESPACE::Bool32 quadOperationsInAllStages = {}; + }; static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceSubgroupProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceSubgroupProperties> + { + using Type = PhysicalDeviceSubgroupProperties; + }; + struct PhysicalDeviceSubgroupSizeControlFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 subgroupSizeControl_ = {}, VULKAN_HPP_NAMESPACE::Bool32 computeFullSubgroups_ = {} ) VULKAN_HPP_NOEXCEPT : subgroupSizeControl( subgroupSizeControl_ ) @@ -53575,6 +58679,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>( this ); @@ -53585,6 +58690,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceSubgroupSizeControlFeaturesEXT const& ) const = default; #else @@ -53602,17 +58708,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 subgroupSizeControl = {}; VULKAN_HPP_NAMESPACE::Bool32 computeFullSubgroups = {}; + }; static_assert( sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceSubgroupSizeControlFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT> + { + using Type = PhysicalDeviceSubgroupSizeControlFeaturesEXT; + }; + struct PhysicalDeviceSubgroupSizeControlPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlPropertiesEXT( uint32_t minSubgroupSize_ = {}, uint32_t maxSubgroupSize_ = {}, uint32_t maxComputeWorkgroupSubgroups_ = {}, @@ -53640,6 +58757,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>( this ); @@ -53650,6 +58768,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceSubgroupSizeControlPropertiesEXT const& ) const = default; #else @@ -53669,6 +58788,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT; void* pNext = {}; @@ -53676,12 +58797,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t maxSubgroupSize = {}; uint32_t maxComputeWorkgroupSubgroups = {}; VULKAN_HPP_NAMESPACE::ShaderStageFlags requiredSubgroupSizeStages = {}; + }; static_assert( sizeof( PhysicalDeviceSubgroupSizeControlPropertiesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceSubgroupSizeControlPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT> + { + using Type = PhysicalDeviceSubgroupSizeControlPropertiesEXT; + }; + struct PhysicalDeviceSurfaceInfo2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; + VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface_ = {} ) VULKAN_HPP_NOEXCEPT : surface( surface_ ) {} @@ -53715,6 +58845,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceSurfaceInfo2KHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( this ); @@ -53725,6 +58856,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceSurfaceInfo2KHR const& ) const = default; #else @@ -53741,16 +58873,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::SurfaceKHR surface = {}; + }; static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceSurfaceInfo2KHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceSurfaceInfo2KHR> + { + using Type = PhysicalDeviceSurfaceInfo2KHR; + }; + struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 texelBufferAlignment_ = {} ) VULKAN_HPP_NOEXCEPT : texelBufferAlignment( texelBufferAlignment_ ) {} @@ -53784,6 +58927,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>( this ); @@ -53794,6 +58938,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const& ) const = default; #else @@ -53810,16 +58955,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 texelBufferAlignment = {}; + }; static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceTexelBufferAlignmentFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT> + { + using Type = PhysicalDeviceTexelBufferAlignmentFeaturesEXT; + }; + struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentPropertiesEXT( VULKAN_HPP_NAMESPACE::DeviceSize storageTexelBufferOffsetAlignmentBytes_ = {}, VULKAN_HPP_NAMESPACE::Bool32 storageTexelBufferOffsetSingleTexelAlignment_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize uniformTexelBufferOffsetAlignmentBytes_ = {}, @@ -53847,6 +59003,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>( this ); @@ -53857,6 +59014,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const& ) const = default; #else @@ -53876,6 +59034,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT; void* pNext = {}; @@ -53883,12 +59043,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 storageTexelBufferOffsetSingleTexelAlignment = {}; VULKAN_HPP_NAMESPACE::DeviceSize uniformTexelBufferOffsetAlignmentBytes = {}; VULKAN_HPP_NAMESPACE::Bool32 uniformTexelBufferOffsetSingleTexelAlignment = {}; + }; static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceTexelBufferAlignmentPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT> + { + using Type = PhysicalDeviceTexelBufferAlignmentPropertiesEXT; + }; + struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 textureCompressionASTC_HDR_ = {} ) VULKAN_HPP_NOEXCEPT : textureCompressionASTC_HDR( textureCompressionASTC_HDR_ ) {} @@ -53922,6 +59091,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>( this ); @@ -53932,6 +59102,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const& ) const = default; #else @@ -53948,16 +59119,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 textureCompressionASTC_HDR = {}; + }; static_assert( sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) == sizeof( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT> + { + using Type = PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; + }; + struct PhysicalDeviceTimelineSemaphoreFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTimelineSemaphoreFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeatures( VULKAN_HPP_NAMESPACE::Bool32 timelineSemaphore_ = {} ) VULKAN_HPP_NOEXCEPT : timelineSemaphore( timelineSemaphore_ ) {} @@ -53991,6 +59173,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceTimelineSemaphoreFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>( this ); @@ -54001,6 +59184,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceTimelineSemaphoreFeatures const& ) const = default; #else @@ -54017,16 +59201,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 timelineSemaphore = {}; + }; static_assert( sizeof( PhysicalDeviceTimelineSemaphoreFeatures ) == sizeof( VkPhysicalDeviceTimelineSemaphoreFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceTimelineSemaphoreFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceTimelineSemaphoreFeatures> + { + using Type = PhysicalDeviceTimelineSemaphoreFeatures; + }; + struct PhysicalDeviceTimelineSemaphoreProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTimelineSemaphoreProperties; + VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreProperties( uint64_t maxTimelineSemaphoreValueDifference_ = {} ) VULKAN_HPP_NOEXCEPT : maxTimelineSemaphoreValueDifference( maxTimelineSemaphoreValueDifference_ ) {} @@ -54048,6 +59243,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceTimelineSemaphoreProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>( this ); @@ -54058,6 +59254,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceTimelineSemaphoreProperties const& ) const = default; #else @@ -54074,16 +59271,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreProperties; void* pNext = {}; uint64_t maxTimelineSemaphoreValueDifference = {}; + }; static_assert( sizeof( PhysicalDeviceTimelineSemaphoreProperties ) == sizeof( VkPhysicalDeviceTimelineSemaphoreProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceTimelineSemaphoreProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceTimelineSemaphoreProperties> + { + using Type = PhysicalDeviceTimelineSemaphoreProperties; + }; + struct PhysicalDeviceToolPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceToolPropertiesEXT; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceToolPropertiesEXT( std::array<char,VK_MAX_EXTENSION_NAME_SIZE> const& name_ = {}, std::array<char,VK_MAX_EXTENSION_NAME_SIZE> const& version_ = {}, VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT purposes_ = {}, @@ -54113,6 +59321,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceToolPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceToolPropertiesEXT*>( this ); @@ -54123,6 +59332,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceToolPropertiesEXT const& ) const = default; #else @@ -54143,6 +59353,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceToolPropertiesEXT; void* pNext = {}; @@ -54151,12 +59363,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT purposes = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> layer = {}; + }; static_assert( sizeof( PhysicalDeviceToolPropertiesEXT ) == sizeof( VkPhysicalDeviceToolPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceToolPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceToolPropertiesEXT> + { + using Type = PhysicalDeviceToolPropertiesEXT; + }; + struct PhysicalDeviceTransformFeedbackFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 transformFeedback_ = {}, VULKAN_HPP_NAMESPACE::Bool32 geometryStreams_ = {} ) VULKAN_HPP_NOEXCEPT : transformFeedback( transformFeedback_ ) @@ -54198,6 +59419,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>( this ); @@ -54208,6 +59430,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceTransformFeedbackFeaturesEXT const& ) const = default; #else @@ -54225,17 +59448,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 transformFeedback = {}; VULKAN_HPP_NAMESPACE::Bool32 geometryStreams = {}; + }; static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceTransformFeedbackFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT> + { + using Type = PhysicalDeviceTransformFeedbackFeaturesEXT; + }; + struct PhysicalDeviceTransformFeedbackPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackPropertiesEXT( uint32_t maxTransformFeedbackStreams_ = {}, uint32_t maxTransformFeedbackBuffers_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize maxTransformFeedbackBufferSize_ = {}, @@ -54275,6 +59509,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>( this ); @@ -54285,6 +59520,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceTransformFeedbackPropertiesEXT const& ) const = default; #else @@ -54310,6 +59546,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT; void* pNext = {}; @@ -54323,12 +59561,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 transformFeedbackStreamsLinesTriangles = {}; VULKAN_HPP_NAMESPACE::Bool32 transformFeedbackRasterizationStreamSelect = {}; VULKAN_HPP_NAMESPACE::Bool32 transformFeedbackDraw = {}; + }; static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceTransformFeedbackPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT> + { + using Type = PhysicalDeviceTransformFeedbackPropertiesEXT; + }; + struct PhysicalDeviceUniformBufferStandardLayoutFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeatures( VULKAN_HPP_NAMESPACE::Bool32 uniformBufferStandardLayout_ = {} ) VULKAN_HPP_NOEXCEPT : uniformBufferStandardLayout( uniformBufferStandardLayout_ ) {} @@ -54362,6 +59609,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>( this ); @@ -54372,6 +59620,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceUniformBufferStandardLayoutFeatures const& ) const = default; #else @@ -54388,16 +59637,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 uniformBufferStandardLayout = {}; + }; static_assert( sizeof( PhysicalDeviceUniformBufferStandardLayoutFeatures ) == sizeof( VkPhysicalDeviceUniformBufferStandardLayoutFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceUniformBufferStandardLayoutFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures> + { + using Type = PhysicalDeviceUniformBufferStandardLayoutFeatures; + }; + struct PhysicalDeviceVariablePointersFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVariablePointersFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( VULKAN_HPP_NAMESPACE::Bool32 variablePointersStorageBuffer_ = {}, VULKAN_HPP_NAMESPACE::Bool32 variablePointers_ = {} ) VULKAN_HPP_NOEXCEPT : variablePointersStorageBuffer( variablePointersStorageBuffer_ ) @@ -54439,6 +59699,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceVariablePointersFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>( this ); @@ -54449,6 +59710,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceVariablePointersFeatures const& ) const = default; #else @@ -54466,17 +59728,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVariablePointersFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 variablePointersStorageBuffer = {}; VULKAN_HPP_NAMESPACE::Bool32 variablePointers = {}; + }; static_assert( sizeof( PhysicalDeviceVariablePointersFeatures ) == sizeof( VkPhysicalDeviceVariablePointersFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceVariablePointersFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceVariablePointersFeatures> + { + using Type = PhysicalDeviceVariablePointersFeatures; + }; + struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 vertexAttributeInstanceRateDivisor_ = {}, VULKAN_HPP_NAMESPACE::Bool32 vertexAttributeInstanceRateZeroDivisor_ = {} ) VULKAN_HPP_NOEXCEPT : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ ) @@ -54518,6 +59791,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>( this ); @@ -54528,6 +59802,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const& ) const = default; #else @@ -54545,17 +59820,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 vertexAttributeInstanceRateDivisor = {}; VULKAN_HPP_NAMESPACE::Bool32 vertexAttributeInstanceRateZeroDivisor = {}; + }; static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceVertexAttributeDivisorFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT> + { + using Type = PhysicalDeviceVertexAttributeDivisorFeaturesEXT; + }; + struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorPropertiesEXT( uint32_t maxVertexAttribDivisor_ = {} ) VULKAN_HPP_NOEXCEPT : maxVertexAttribDivisor( maxVertexAttribDivisor_ ) {} @@ -54577,6 +59863,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>( this ); @@ -54587,6 +59874,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const& ) const = default; #else @@ -54603,16 +59891,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT; void* pNext = {}; uint32_t maxVertexAttribDivisor = {}; + }; static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceVertexAttributeDivisorPropertiesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT> + { + using Type = PhysicalDeviceVertexAttributeDivisorPropertiesEXT; + }; + struct PhysicalDeviceVulkan11Features { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan11Features; + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan11Features( VULKAN_HPP_NAMESPACE::Bool32 storageBuffer16BitAccess_ = {}, VULKAN_HPP_NAMESPACE::Bool32 uniformAndStorageBuffer16BitAccess_ = {}, VULKAN_HPP_NAMESPACE::Bool32 storagePushConstant16_ = {}, @@ -54734,6 +60033,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceVulkan11Features const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>( this ); @@ -54744,6 +60044,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceVulkan11Features*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceVulkan11Features const& ) const = default; #else @@ -54771,6 +60072,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVulkan11Features; void* pNext = {}; @@ -54786,12 +60089,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 protectedMemory = {}; VULKAN_HPP_NAMESPACE::Bool32 samplerYcbcrConversion = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderDrawParameters = {}; + }; static_assert( sizeof( PhysicalDeviceVulkan11Features ) == sizeof( VkPhysicalDeviceVulkan11Features ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceVulkan11Features>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceVulkan11Features> + { + using Type = PhysicalDeviceVulkan11Features; + }; + struct PhysicalDeviceVulkan11Properties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan11Properties; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Properties( std::array<uint8_t,VK_UUID_SIZE> const& deviceUUID_ = {}, std::array<uint8_t,VK_UUID_SIZE> const& driverUUID_ = {}, std::array<uint8_t,VK_LUID_SIZE> const& deviceLUID_ = {}, @@ -54841,6 +60153,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceVulkan11Properties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>( this ); @@ -54851,6 +60164,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceVulkan11Properties const& ) const = default; #else @@ -54881,6 +60195,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVulkan11Properties; void* pNext = {}; @@ -54899,12 +60215,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 protectedNoFault = {}; uint32_t maxPerSetDescriptors = {}; VULKAN_HPP_NAMESPACE::DeviceSize maxMemoryAllocationSize = {}; + }; static_assert( sizeof( PhysicalDeviceVulkan11Properties ) == sizeof( VkPhysicalDeviceVulkan11Properties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceVulkan11Properties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceVulkan11Properties> + { + using Type = PhysicalDeviceVulkan11Properties; + }; + struct PhysicalDeviceVulkan12Features { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan12Features; + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan12Features( VULKAN_HPP_NAMESPACE::Bool32 samplerMirrorClampToEdge_ = {}, VULKAN_HPP_NAMESPACE::Bool32 drawIndirectCount_ = {}, VULKAN_HPP_NAMESPACE::Bool32 storageBuffer8BitAccess_ = {}, @@ -55306,6 +60631,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceVulkan12Features const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>( this ); @@ -55316,6 +60642,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceVulkan12Features*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceVulkan12Features const& ) const = default; #else @@ -55378,6 +60705,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVulkan12Features; void* pNext = {}; @@ -55428,12 +60757,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 shaderOutputViewportIndex = {}; VULKAN_HPP_NAMESPACE::Bool32 shaderOutputLayer = {}; VULKAN_HPP_NAMESPACE::Bool32 subgroupBroadcastDynamicId = {}; + }; static_assert( sizeof( PhysicalDeviceVulkan12Features ) == sizeof( VkPhysicalDeviceVulkan12Features ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceVulkan12Features>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceVulkan12Features> + { + using Type = PhysicalDeviceVulkan12Features; + }; + struct PhysicalDeviceVulkan12Properties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan12Properties; + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Properties( VULKAN_HPP_NAMESPACE::DriverId driverID_ = VULKAN_HPP_NAMESPACE::DriverId::eAmdProprietary, std::array<char,VK_MAX_DRIVER_NAME_SIZE> const& driverName_ = {}, std::array<char,VK_MAX_DRIVER_INFO_SIZE> const& driverInfo_ = {}, @@ -55557,6 +60895,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceVulkan12Properties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>( this ); @@ -55567,6 +60906,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceVulkan12Properties const& ) const = default; #else @@ -55634,6 +60974,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVulkan12Properties; void* pNext = {}; @@ -55689,12 +61031,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 filterMinmaxImageComponentMapping = {}; uint64_t maxTimelineSemaphoreValueDifference = {}; VULKAN_HPP_NAMESPACE::SampleCountFlags framebufferIntegerColorSampleCounts = {}; + }; static_assert( sizeof( PhysicalDeviceVulkan12Properties ) == sizeof( VkPhysicalDeviceVulkan12Properties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceVulkan12Properties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceVulkan12Properties> + { + using Type = PhysicalDeviceVulkan12Properties; + }; + struct PhysicalDeviceVulkanMemoryModelFeatures { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkanMemoryModelFeatures; + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeatures( VULKAN_HPP_NAMESPACE::Bool32 vulkanMemoryModel_ = {}, VULKAN_HPP_NAMESPACE::Bool32 vulkanMemoryModelDeviceScope_ = {}, VULKAN_HPP_NAMESPACE::Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = {} ) VULKAN_HPP_NOEXCEPT @@ -55744,6 +61095,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceVulkanMemoryModelFeatures const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>( this ); @@ -55754,6 +61106,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceVulkanMemoryModelFeatures const& ) const = default; #else @@ -55772,18 +61125,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeatures; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 vulkanMemoryModel = {}; VULKAN_HPP_NAMESPACE::Bool32 vulkanMemoryModelDeviceScope = {}; VULKAN_HPP_NAMESPACE::Bool32 vulkanMemoryModelAvailabilityVisibilityChains = {}; + }; static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeatures ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceVulkanMemoryModelFeatures>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceVulkanMemoryModelFeatures> + { + using Type = PhysicalDeviceVulkanMemoryModelFeatures; + }; + struct PhysicalDeviceYcbcrImageArraysFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT; + VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 ycbcrImageArrays_ = {} ) VULKAN_HPP_NOEXCEPT : ycbcrImageArrays( ycbcrImageArrays_ ) {} @@ -55817,6 +61181,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>( this ); @@ -55827,6 +61192,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PhysicalDeviceYcbcrImageArraysFeaturesEXT const& ) const = default; #else @@ -55843,16 +61209,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 ycbcrImageArrays = {}; + }; static_assert( sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) == sizeof( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PhysicalDeviceYcbcrImageArraysFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT> + { + using Type = PhysicalDeviceYcbcrImageArraysFeaturesEXT; + }; + struct PipelineCacheCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCacheCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags flags_ = {}, size_t initialDataSize_ = {}, const void* pInitialData_ = {} ) VULKAN_HPP_NOEXCEPT @@ -55902,6 +61279,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineCacheCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineCacheCreateInfo*>( this ); @@ -55912,6 +61290,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineCacheCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineCacheCreateInfo const& ) const = default; #else @@ -55930,18 +61309,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineCacheCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags flags = {}; size_t initialDataSize = {}; const void* pInitialData = {}; + }; static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineCacheCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineCacheCreateInfo> + { + using Type = PipelineCacheCreateInfo; + }; + struct PipelineColorBlendAdvancedStateCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 srcPremultiplied_ = {}, VULKAN_HPP_NAMESPACE::Bool32 dstPremultiplied_ = {}, VULKAN_HPP_NAMESPACE::BlendOverlapEXT blendOverlap_ = VULKAN_HPP_NAMESPACE::BlendOverlapEXT::eUncorrelated ) VULKAN_HPP_NOEXCEPT @@ -55991,6 +61381,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>( this ); @@ -56001,6 +61392,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineColorBlendAdvancedStateCreateInfoEXT const& ) const = default; #else @@ -56019,18 +61411,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 srcPremultiplied = {}; VULKAN_HPP_NAMESPACE::Bool32 dstPremultiplied = {}; VULKAN_HPP_NAMESPACE::BlendOverlapEXT blendOverlap = VULKAN_HPP_NAMESPACE::BlendOverlapEXT::eUncorrelated; + }; static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineColorBlendAdvancedStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT> + { + using Type = PipelineColorBlendAdvancedStateCreateInfoEXT; + }; + struct PipelineCompilerControlCreateInfoAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCompilerControlCreateInfoAMD; + VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD compilerControlFlags_ = {} ) VULKAN_HPP_NOEXCEPT : compilerControlFlags( compilerControlFlags_ ) {} @@ -56064,6 +61467,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineCompilerControlCreateInfoAMD const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>( this ); @@ -56074,6 +61478,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineCompilerControlCreateInfoAMD const& ) const = default; #else @@ -56090,16 +61495,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineCompilerControlCreateInfoAMD; const void* pNext = {}; VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD compilerControlFlags = {}; + }; static_assert( sizeof( PipelineCompilerControlCreateInfoAMD ) == sizeof( VkPipelineCompilerControlCreateInfoAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineCompilerControlCreateInfoAMD>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineCompilerControlCreateInfoAMD> + { + using Type = PipelineCompilerControlCreateInfoAMD; + }; + struct PipelineCoverageModulationStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCoverageModulationStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagsNV flags_ = {}, VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode_ = VULKAN_HPP_NAMESPACE::CoverageModulationModeNV::eNone, VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable_ = {}, @@ -56165,6 +61581,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineCoverageModulationStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>( this ); @@ -56175,6 +61592,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineCoverageModulationStateCreateInfoNV const& ) const = default; #else @@ -56195,6 +61613,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV; const void* pNext = {}; @@ -56203,12 +61623,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable = {}; uint32_t coverageModulationTableCount = {}; const float* pCoverageModulationTable = {}; + }; static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineCoverageModulationStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineCoverageModulationStateCreateInfoNV> + { + using Type = PipelineCoverageModulationStateCreateInfoNV; + }; + struct PipelineCoverageReductionStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCoverageReductionStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV flags_ = {}, VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode_ = VULKAN_HPP_NAMESPACE::CoverageReductionModeNV::eMerge ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -56250,6 +61679,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineCoverageReductionStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>( this ); @@ -56260,6 +61690,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineCoverageReductionStateCreateInfoNV const& ) const = default; #else @@ -56277,17 +61708,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineCoverageReductionStateCreateInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV flags = {}; VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode = VULKAN_HPP_NAMESPACE::CoverageReductionModeNV::eMerge; + }; static_assert( sizeof( PipelineCoverageReductionStateCreateInfoNV ) == sizeof( VkPipelineCoverageReductionStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineCoverageReductionStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineCoverageReductionStateCreateInfoNV> + { + using Type = PipelineCoverageReductionStateCreateInfoNV; + }; + struct PipelineCoverageToColorStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCoverageToColorStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV flags_ = {}, VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable_ = {}, uint32_t coverageToColorLocation_ = {} ) VULKAN_HPP_NOEXCEPT @@ -56337,6 +61779,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineCoverageToColorStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>( this ); @@ -56347,6 +61790,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineCoverageToColorStateCreateInfoNV const& ) const = default; #else @@ -56365,18 +61809,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV flags = {}; VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable = {}; uint32_t coverageToColorLocation = {}; + }; static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineCoverageToColorStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineCoverageToColorStateCreateInfoNV> + { + using Type = PipelineCoverageToColorStateCreateInfoNV; + }; + struct PipelineCreationFeedbackEXT { + VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackEXT( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagsEXT flags_ = {}, uint64_t duration_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -56394,6 +61848,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineCreationFeedbackEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineCreationFeedbackEXT*>( this ); @@ -56404,6 +61859,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineCreationFeedbackEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineCreationFeedbackEXT const& ) const = default; #else @@ -56419,15 +61875,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagsEXT flags = {}; uint64_t duration = {}; + }; static_assert( sizeof( PipelineCreationFeedbackEXT ) == sizeof( VkPipelineCreationFeedbackEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineCreationFeedbackEXT>::value, "struct wrapper is not a standard layout!" ); struct PipelineCreationFeedbackCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCreationFeedbackCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = {}, uint32_t pipelineStageCreationFeedbackCount_ = {}, VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = {} ) VULKAN_HPP_NOEXCEPT @@ -56477,6 +61938,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineCreationFeedbackCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>( this ); @@ -56487,6 +61949,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineCreationFeedbackCreateInfoEXT const& ) const = default; #else @@ -56505,18 +61968,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT* pPipelineCreationFeedback = {}; uint32_t pipelineStageCreationFeedbackCount = {}; VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks = {}; + }; static_assert( sizeof( PipelineCreationFeedbackCreateInfoEXT ) == sizeof( VkPipelineCreationFeedbackCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineCreationFeedbackCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineCreationFeedbackCreateInfoEXT> + { + using Type = PipelineCreationFeedbackCreateInfoEXT; + }; + struct PipelineDiscardRectangleStateCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagsEXT flags_ = {}, VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode_ = VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT::eInclusive, uint32_t discardRectangleCount_ = {}, @@ -56574,6 +62048,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineDiscardRectangleStateCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>( this ); @@ -56584,6 +62059,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineDiscardRectangleStateCreateInfoEXT const& ) const = default; #else @@ -56603,6 +62079,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; const void* pNext = {}; @@ -56610,12 +62088,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode = VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT::eInclusive; uint32_t discardRectangleCount = {}; const VULKAN_HPP_NAMESPACE::Rect2D* pDiscardRectangles = {}; + }; static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineDiscardRectangleStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineDiscardRectangleStateCreateInfoEXT> + { + using Type = PipelineDiscardRectangleStateCreateInfoEXT; + }; + struct PipelineExecutableInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutableInfoKHR; + VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline_ = {}, uint32_t executableIndex_ = {} ) VULKAN_HPP_NOEXCEPT : pipeline( pipeline_ ) @@ -56657,6 +62144,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineExecutableInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineExecutableInfoKHR*>( this ); @@ -56667,6 +62155,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineExecutableInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineExecutableInfoKHR const& ) const = default; #else @@ -56684,17 +62173,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Pipeline pipeline = {}; uint32_t executableIndex = {}; + }; static_assert( sizeof( PipelineExecutableInfoKHR ) == sizeof( VkPipelineExecutableInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineExecutableInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineExecutableInfoKHR> + { + using Type = PipelineExecutableInfoKHR; + }; + struct PipelineExecutableInternalRepresentationKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutableInternalRepresentationKHR; + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInternalRepresentationKHR( std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = {}, std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = {}, VULKAN_HPP_NAMESPACE::Bool32 isText_ = {}, @@ -56724,6 +62224,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineExecutableInternalRepresentationKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineExecutableInternalRepresentationKHR*>( this ); @@ -56734,6 +62235,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineExecutableInternalRepresentationKHR const& ) const = default; #else @@ -56754,6 +62256,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableInternalRepresentationKHR; void* pNext = {}; @@ -56762,12 +62266,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 isText = {}; size_t dataSize = {}; void* pData = {}; + }; static_assert( sizeof( PipelineExecutableInternalRepresentationKHR ) == sizeof( VkPipelineExecutableInternalRepresentationKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineExecutableInternalRepresentationKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineExecutableInternalRepresentationKHR> + { + using Type = PipelineExecutableInternalRepresentationKHR; + }; + struct PipelineExecutablePropertiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutablePropertiesKHR; + VULKAN_HPP_CONSTEXPR_14 PipelineExecutablePropertiesKHR( VULKAN_HPP_NAMESPACE::ShaderStageFlags stages_ = {}, std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = {}, std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = {}, @@ -56795,6 +62308,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineExecutablePropertiesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineExecutablePropertiesKHR*>( this ); @@ -56805,6 +62319,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineExecutablePropertiesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineExecutablePropertiesKHR const& ) const = default; #else @@ -56824,6 +62339,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutablePropertiesKHR; void* pNext = {}; @@ -56831,10 +62348,17 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> name = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {}; uint32_t subgroupSize = {}; + }; static_assert( sizeof( PipelineExecutablePropertiesKHR ) == sizeof( VkPipelineExecutablePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineExecutablePropertiesKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineExecutablePropertiesKHR> + { + using Type = PipelineExecutablePropertiesKHR; + }; + union PipelineExecutableStatisticValueKHR { PipelineExecutableStatisticValueKHR( VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR const& rhs ) VULKAN_HPP_NOEXCEPT @@ -56843,24 +62367,20 @@ namespace VULKAN_HPP_NAMESPACE } PipelineExecutableStatisticValueKHR( VULKAN_HPP_NAMESPACE::Bool32 b32_ = {} ) - { - b32 = b32_; - } + : b32( b32_ ) + {} PipelineExecutableStatisticValueKHR( int64_t i64_ ) - { - i64 = i64_; - } + : i64( i64_ ) + {} PipelineExecutableStatisticValueKHR( uint64_t u64_ ) - { - u64 = u64_; - } + : u64( u64_ ) + {} PipelineExecutableStatisticValueKHR( double f64_ ) - { - f64 = f64_; - } + : f64( f64_ ) + {} PipelineExecutableStatisticValueKHR & setB32( VULKAN_HPP_NAMESPACE::Bool32 b32_ ) VULKAN_HPP_NOEXCEPT { @@ -56917,6 +62437,8 @@ namespace VULKAN_HPP_NAMESPACE struct PipelineExecutableStatisticKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutableStatisticKHR; + PipelineExecutableStatisticKHR( std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = {}, std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = {}, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR format_ = VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR::eBool32, @@ -56944,6 +62466,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineExecutableStatisticKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineExecutableStatisticKHR*>( this ); @@ -56954,6 +62477,9 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineExecutableStatisticKHR*>( this ); } + + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableStatisticKHR; void* pNext = {}; @@ -56961,12 +62487,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> description = {}; VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR format = VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR::eBool32; VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR value = {}; + }; static_assert( sizeof( PipelineExecutableStatisticKHR ) == sizeof( VkPipelineExecutableStatisticKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineExecutableStatisticKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineExecutableStatisticKHR> + { + using Type = PipelineExecutableStatisticKHR; + }; + struct PipelineInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineInfoKHR; + VULKAN_HPP_CONSTEXPR PipelineInfoKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline_ = {} ) VULKAN_HPP_NOEXCEPT : pipeline( pipeline_ ) {} @@ -57000,6 +62535,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineInfoKHR*>( this ); @@ -57010,6 +62546,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineInfoKHR const& ) const = default; #else @@ -57026,16 +62563,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Pipeline pipeline = {}; + }; static_assert( sizeof( PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineInfoKHR> + { + using Type = PipelineInfoKHR; + }; + struct PushConstantRange { + VULKAN_HPP_CONSTEXPR PushConstantRange( VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags_ = {}, uint32_t offset_ = {}, uint32_t size_ = {} ) VULKAN_HPP_NOEXCEPT @@ -57073,6 +62620,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPushConstantRange const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPushConstantRange*>( this ); @@ -57083,6 +62631,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPushConstantRange*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PushConstantRange const& ) const = default; #else @@ -57099,16 +62648,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags = {}; uint32_t offset = {}; uint32_t size = {}; + }; static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PushConstantRange>::value, "struct wrapper is not a standard layout!" ); struct PipelineLayoutCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineLayoutCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags flags_ = {}, uint32_t setLayoutCount_ = {}, const VULKAN_HPP_NAMESPACE::DescriptorSetLayout* pSetLayouts_ = {}, @@ -57174,6 +62728,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineLayoutCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineLayoutCreateInfo*>( this ); @@ -57184,6 +62739,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineLayoutCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineLayoutCreateInfo const& ) const = default; #else @@ -57204,6 +62760,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineLayoutCreateInfo; const void* pNext = {}; @@ -57212,13 +62770,22 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::DescriptorSetLayout* pSetLayouts = {}; uint32_t pushConstantRangeCount = {}; const VULKAN_HPP_NAMESPACE::PushConstantRange* pPushConstantRanges = {}; + }; static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineLayoutCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineLayoutCreateInfo> + { + using Type = PipelineLayoutCreateInfo; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct PipelineLibraryCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineLibraryCreateInfoKHR; + VULKAN_HPP_CONSTEXPR PipelineLibraryCreateInfoKHR( uint32_t libraryCount_ = {}, const VULKAN_HPP_NAMESPACE::Pipeline* pLibraries_ = {} ) VULKAN_HPP_NOEXCEPT : libraryCount( libraryCount_ ) @@ -57260,6 +62827,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineLibraryCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineLibraryCreateInfoKHR*>( this ); @@ -57270,6 +62838,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineLibraryCreateInfoKHR const& ) const = default; #else @@ -57287,18 +62856,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineLibraryCreateInfoKHR; const void* pNext = {}; uint32_t libraryCount = {}; const VULKAN_HPP_NAMESPACE::Pipeline* pLibraries = {}; + }; static_assert( sizeof( PipelineLibraryCreateInfoKHR ) == sizeof( VkPipelineLibraryCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineLibraryCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::ePipelineLibraryCreateInfoKHR> + { + using Type = PipelineLibraryCreateInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct PipelineRasterizationConservativeStateCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = {}, VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode_ = VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT::eDisabled, float extraPrimitiveOverestimationSize_ = {} ) VULKAN_HPP_NOEXCEPT @@ -57348,6 +62928,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineRasterizationConservativeStateCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>( this ); @@ -57358,6 +62939,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineRasterizationConservativeStateCreateInfoEXT const& ) const = default; #else @@ -57376,18 +62958,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT flags = {}; VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode = VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT::eDisabled; float extraPrimitiveOverestimationSize = {}; + }; static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineRasterizationConservativeStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT> + { + using Type = PipelineRasterizationConservativeStateCreateInfoEXT; + }; + struct PipelineRasterizationDepthClipStateCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = {}, VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -57429,6 +63022,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineRasterizationDepthClipStateCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>( this ); @@ -57439,6 +63033,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineRasterizationDepthClipStateCreateInfoEXT const& ) const = default; #else @@ -57456,17 +63051,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT flags = {}; VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable = {}; + }; static_assert( sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationDepthClipStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineRasterizationDepthClipStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT> + { + using Type = PipelineRasterizationDepthClipStateCreateInfoEXT; + }; + struct PipelineRasterizationLineStateCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationLineStateCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode_ = VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT::eDefault, VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable_ = {}, uint32_t lineStippleFactor_ = {}, @@ -57524,6 +63130,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineRasterizationLineStateCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>( this ); @@ -57534,6 +63141,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineRasterizationLineStateCreateInfoEXT const& ) const = default; #else @@ -57553,6 +63161,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRasterizationLineStateCreateInfoEXT; const void* pNext = {}; @@ -57560,12 +63170,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable = {}; uint32_t lineStippleFactor = {}; uint16_t lineStipplePattern = {}; + }; static_assert( sizeof( PipelineRasterizationLineStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationLineStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineRasterizationLineStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineRasterizationLineStateCreateInfoEXT> + { + using Type = PipelineRasterizationLineStateCreateInfoEXT; + }; + struct PipelineRasterizationStateRasterizationOrderAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD; + VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( VULKAN_HPP_NAMESPACE::RasterizationOrderAMD rasterizationOrder_ = VULKAN_HPP_NAMESPACE::RasterizationOrderAMD::eStrict ) VULKAN_HPP_NOEXCEPT : rasterizationOrder( rasterizationOrder_ ) {} @@ -57599,6 +63218,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineRasterizationStateRasterizationOrderAMD const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>( this ); @@ -57609,6 +63229,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineRasterizationStateRasterizationOrderAMD const& ) const = default; #else @@ -57625,16 +63246,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD; const void* pNext = {}; VULKAN_HPP_NAMESPACE::RasterizationOrderAMD rasterizationOrder = VULKAN_HPP_NAMESPACE::RasterizationOrderAMD::eStrict; + }; static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineRasterizationStateRasterizationOrderAMD>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineRasterizationStateRasterizationOrderAMD> + { + using Type = PipelineRasterizationStateRasterizationOrderAMD; + }; + struct PipelineRasterizationStateStreamCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT flags_ = {}, uint32_t rasterizationStream_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -57676,6 +63308,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineRasterizationStateStreamCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>( this ); @@ -57686,6 +63319,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineRasterizationStateStreamCreateInfoEXT const& ) const = default; #else @@ -57703,17 +63337,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT flags = {}; uint32_t rasterizationStream = {}; + }; static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineRasterizationStateStreamCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineRasterizationStateStreamCreateInfoEXT> + { + using Type = PipelineRasterizationStateStreamCreateInfoEXT; + }; + struct PipelineRepresentativeFragmentTestStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable_ = {} ) VULKAN_HPP_NOEXCEPT : representativeFragmentTestEnable( representativeFragmentTestEnable_ ) {} @@ -57747,6 +63392,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>( this ); @@ -57757,6 +63403,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineRepresentativeFragmentTestStateCreateInfoNV const& ) const = default; #else @@ -57773,16 +63420,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable = {}; + }; static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineRepresentativeFragmentTestStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV> + { + using Type = PipelineRepresentativeFragmentTestStateCreateInfoNV; + }; + struct PipelineSampleLocationsStateCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable_ = {}, VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ = {} ) VULKAN_HPP_NOEXCEPT : sampleLocationsEnable( sampleLocationsEnable_ ) @@ -57818,12 +63476,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsInfo( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ ) VULKAN_HPP_NOEXCEPT + PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsInfo( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfo_ ) VULKAN_HPP_NOEXCEPT { sampleLocationsInfo = sampleLocationsInfo_; return *this; } + operator VkPipelineSampleLocationsStateCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>( this ); @@ -57834,6 +63493,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineSampleLocationsStateCreateInfoEXT const& ) const = default; #else @@ -57851,17 +63511,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable = {}; VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo = {}; + }; static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineSampleLocationsStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineSampleLocationsStateCreateInfoEXT> + { + using Type = PipelineSampleLocationsStateCreateInfoEXT; + }; + struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( uint32_t requiredSubgroupSize_ = {} ) VULKAN_HPP_NOEXCEPT : requiredSubgroupSize( requiredSubgroupSize_ ) {} @@ -57883,6 +63554,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>( this ); @@ -57893,6 +63565,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const& ) const = default; #else @@ -57909,16 +63582,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; void* pNext = {}; uint32_t requiredSubgroupSize = {}; + }; static_assert( sizeof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) == sizeof( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT> + { + using Type = PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; + }; + struct PipelineTessellationDomainOriginStateCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo; + VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin_ = VULKAN_HPP_NAMESPACE::TessellationDomainOrigin::eUpperLeft ) VULKAN_HPP_NOEXCEPT : domainOrigin( domainOrigin_ ) {} @@ -57952,6 +63636,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineTessellationDomainOriginStateCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>( this ); @@ -57962,6 +63647,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineTessellationDomainOriginStateCreateInfo const& ) const = default; #else @@ -57978,16 +63664,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin = VULKAN_HPP_NAMESPACE::TessellationDomainOrigin::eUpperLeft; + }; static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineTessellationDomainOriginStateCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineTessellationDomainOriginStateCreateInfo> + { + using Type = PipelineTessellationDomainOriginStateCreateInfo; + }; + struct VertexInputBindingDivisorDescriptionEXT { + VULKAN_HPP_CONSTEXPR VertexInputBindingDivisorDescriptionEXT( uint32_t binding_ = {}, uint32_t divisor_ = {} ) VULKAN_HPP_NOEXCEPT : binding( binding_ ) @@ -58017,6 +63713,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkVertexInputBindingDivisorDescriptionEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkVertexInputBindingDivisorDescriptionEXT*>( this ); @@ -58027,6 +63724,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( VertexInputBindingDivisorDescriptionEXT const& ) const = default; #else @@ -58042,15 +63740,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t binding = {}; uint32_t divisor = {}; + }; static_assert( sizeof( VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<VertexInputBindingDivisorDescriptionEXT>::value, "struct wrapper is not a standard layout!" ); struct PipelineVertexInputDivisorStateCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT; + VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = {}, const VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = {} ) VULKAN_HPP_NOEXCEPT : vertexBindingDivisorCount( vertexBindingDivisorCount_ ) @@ -58092,6 +63795,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineVertexInputDivisorStateCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>( this ); @@ -58102,6 +63806,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineVertexInputDivisorStateCreateInfoEXT const& ) const = default; #else @@ -58119,17 +63824,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT; const void* pNext = {}; uint32_t vertexBindingDivisorCount = {}; const VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors = {}; + }; static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineVertexInputDivisorStateCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT> + { + using Type = PipelineVertexInputDivisorStateCreateInfoEXT; + }; + struct PipelineViewportCoarseSampleOrderStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType_ = VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV::eDefault, uint32_t customSampleOrderCount_ = {}, const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV* pCustomSampleOrders_ = {} ) VULKAN_HPP_NOEXCEPT @@ -58179,6 +63895,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>( this ); @@ -58189,6 +63906,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineViewportCoarseSampleOrderStateCreateInfoNV const& ) const = default; #else @@ -58207,18 +63925,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType = VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV::eDefault; uint32_t customSampleOrderCount = {}; const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV* pCustomSampleOrders = {}; + }; static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineViewportCoarseSampleOrderStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV> + { + using Type = PipelineViewportCoarseSampleOrderStateCreateInfoNV; + }; + struct PipelineViewportExclusiveScissorStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = {}, const VULKAN_HPP_NAMESPACE::Rect2D* pExclusiveScissors_ = {} ) VULKAN_HPP_NOEXCEPT : exclusiveScissorCount( exclusiveScissorCount_ ) @@ -58260,6 +63989,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>( this ); @@ -58270,6 +64000,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineViewportExclusiveScissorStateCreateInfoNV const& ) const = default; #else @@ -58287,17 +64018,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV; const void* pNext = {}; uint32_t exclusiveScissorCount = {}; const VULKAN_HPP_NAMESPACE::Rect2D* pExclusiveScissors = {}; + }; static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineViewportExclusiveScissorStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV> + { + using Type = PipelineViewportExclusiveScissorStateCreateInfoNV; + }; + struct ShadingRatePaletteNV { + VULKAN_HPP_CONSTEXPR ShadingRatePaletteNV( uint32_t shadingRatePaletteEntryCount_ = {}, const VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ = {} ) VULKAN_HPP_NOEXCEPT : shadingRatePaletteEntryCount( shadingRatePaletteEntryCount_ ) @@ -58327,6 +64068,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkShadingRatePaletteNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkShadingRatePaletteNV*>( this ); @@ -58337,6 +64079,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkShadingRatePaletteNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ShadingRatePaletteNV const& ) const = default; #else @@ -58352,15 +64095,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t shadingRatePaletteEntryCount = {}; const VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV* pShadingRatePaletteEntries = {}; + }; static_assert( sizeof( ShadingRatePaletteNV ) == sizeof( VkShadingRatePaletteNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ShadingRatePaletteNV>::value, "struct wrapper is not a standard layout!" ); struct PipelineViewportShadingRateImageStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable_ = {}, uint32_t viewportCount_ = {}, const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV* pShadingRatePalettes_ = {} ) VULKAN_HPP_NOEXCEPT @@ -58410,6 +64158,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineViewportShadingRateImageStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>( this ); @@ -58420,6 +64169,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineViewportShadingRateImageStateCreateInfoNV const& ) const = default; #else @@ -58438,18 +64188,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable = {}; uint32_t viewportCount = {}; const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV* pShadingRatePalettes = {}; + }; static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineViewportShadingRateImageStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV> + { + using Type = PipelineViewportShadingRateImageStateCreateInfoNV; + }; + struct ViewportSwizzleNV { + VULKAN_HPP_CONSTEXPR ViewportSwizzleNV( VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV x_ = VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV::ePositiveX, VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV y_ = VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV::ePositiveX, VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV z_ = VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV::ePositiveX, @@ -58495,6 +64255,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkViewportSwizzleNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkViewportSwizzleNV*>( this ); @@ -58505,6 +64266,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkViewportSwizzleNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ViewportSwizzleNV const& ) const = default; #else @@ -58522,17 +64284,22 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV x = VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV::ePositiveX; VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV y = VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV::ePositiveX; VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV z = VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV::ePositiveX; VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV w = VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV::ePositiveX; + }; static_assert( sizeof( ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ViewportSwizzleNV>::value, "struct wrapper is not a standard layout!" ); struct PipelineViewportSwizzleStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV flags_ = {}, uint32_t viewportCount_ = {}, const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV* pViewportSwizzles_ = {} ) VULKAN_HPP_NOEXCEPT @@ -58582,6 +64349,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineViewportSwizzleStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>( this ); @@ -58592,6 +64360,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineViewportSwizzleStateCreateInfoNV const& ) const = default; #else @@ -58610,18 +64379,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV flags = {}; uint32_t viewportCount = {}; const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV* pViewportSwizzles = {}; + }; static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineViewportSwizzleStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineViewportSwizzleStateCreateInfoNV> + { + using Type = PipelineViewportSwizzleStateCreateInfoNV; + }; + struct ViewportWScalingNV { + VULKAN_HPP_CONSTEXPR ViewportWScalingNV( float xcoeff_ = {}, float ycoeff_ = {} ) VULKAN_HPP_NOEXCEPT : xcoeff( xcoeff_ ) @@ -58651,6 +64430,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkViewportWScalingNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkViewportWScalingNV*>( this ); @@ -58661,6 +64441,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkViewportWScalingNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ViewportWScalingNV const& ) const = default; #else @@ -58676,15 +64457,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: float xcoeff = {}; float ycoeff = {}; + }; static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ViewportWScalingNV>::value, "struct wrapper is not a standard layout!" ); struct PipelineViewportWScalingStateCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportWScalingStateCreateInfoNV; + VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable_ = {}, uint32_t viewportCount_ = {}, const VULKAN_HPP_NAMESPACE::ViewportWScalingNV* pViewportWScalings_ = {} ) VULKAN_HPP_NOEXCEPT @@ -58734,6 +64520,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPipelineViewportWScalingStateCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>( this ); @@ -58744,6 +64531,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PipelineViewportWScalingStateCreateInfoNV const& ) const = default; #else @@ -58762,19 +64550,30 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable = {}; uint32_t viewportCount = {}; const VULKAN_HPP_NAMESPACE::ViewportWScalingNV* pViewportWScalings = {}; + }; static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PipelineViewportWScalingStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePipelineViewportWScalingStateCreateInfoNV> + { + using Type = PipelineViewportWScalingStateCreateInfoNV; + }; + #ifdef VK_USE_PLATFORM_GGP struct PresentFrameTokenGGP { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentFrameTokenGGP; + VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( GgpFrameToken frameToken_ = {} ) VULKAN_HPP_NOEXCEPT : frameToken( frameToken_ ) {} @@ -58808,6 +64607,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPresentFrameTokenGGP const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPresentFrameTokenGGP*>( this ); @@ -58818,6 +64618,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPresentFrameTokenGGP*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PresentFrameTokenGGP const& ) const = default; #else @@ -58834,17 +64635,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePresentFrameTokenGGP; const void* pNext = {}; GgpFrameToken frameToken = {}; + }; static_assert( sizeof( PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PresentFrameTokenGGP>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::ePresentFrameTokenGGP> + { + using Type = PresentFrameTokenGGP; + }; #endif /*VK_USE_PLATFORM_GGP*/ struct PresentInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentInfoKHR; + VULKAN_HPP_CONSTEXPR PresentInfoKHR( uint32_t waitSemaphoreCount_ = {}, const VULKAN_HPP_NAMESPACE::Semaphore* pWaitSemaphores_ = {}, uint32_t swapchainCount_ = {}, @@ -58918,6 +64730,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPresentInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPresentInfoKHR*>( this ); @@ -58928,6 +64741,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPresentInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PresentInfoKHR const& ) const = default; #else @@ -58949,6 +64763,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePresentInfoKHR; const void* pNext = {}; @@ -58958,12 +64774,20 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::SwapchainKHR* pSwapchains = {}; const uint32_t* pImageIndices = {}; VULKAN_HPP_NAMESPACE::Result* pResults = {}; + }; static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PresentInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePresentInfoKHR> + { + using Type = PresentInfoKHR; + }; + struct RectLayerKHR { + VULKAN_HPP_CONSTEXPR RectLayerKHR( VULKAN_HPP_NAMESPACE::Offset2D offset_ = {}, VULKAN_HPP_NAMESPACE::Extent2D extent_ = {}, uint32_t layer_ = {} ) VULKAN_HPP_NOEXCEPT @@ -58990,13 +64814,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - RectLayerKHR & setOffset( VULKAN_HPP_NAMESPACE::Offset2D offset_ ) VULKAN_HPP_NOEXCEPT + RectLayerKHR & setOffset( VULKAN_HPP_NAMESPACE::Offset2D const & offset_ ) VULKAN_HPP_NOEXCEPT { offset = offset_; return *this; } - RectLayerKHR & setExtent( VULKAN_HPP_NAMESPACE::Extent2D extent_ ) VULKAN_HPP_NOEXCEPT + RectLayerKHR & setExtent( VULKAN_HPP_NAMESPACE::Extent2D const & extent_ ) VULKAN_HPP_NOEXCEPT { extent = extent_; return *this; @@ -59008,6 +64832,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRectLayerKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRectLayerKHR*>( this ); @@ -59018,6 +64843,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRectLayerKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RectLayerKHR const& ) const = default; #else @@ -59034,16 +64860,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Offset2D offset = {}; VULKAN_HPP_NAMESPACE::Extent2D extent = {}; uint32_t layer = {}; + }; static_assert( sizeof( RectLayerKHR ) == sizeof( VkRectLayerKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RectLayerKHR>::value, "struct wrapper is not a standard layout!" ); struct PresentRegionKHR { + VULKAN_HPP_CONSTEXPR PresentRegionKHR( uint32_t rectangleCount_ = {}, const VULKAN_HPP_NAMESPACE::RectLayerKHR* pRectangles_ = {} ) VULKAN_HPP_NOEXCEPT : rectangleCount( rectangleCount_ ) @@ -59073,6 +64903,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPresentRegionKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPresentRegionKHR*>( this ); @@ -59083,6 +64914,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPresentRegionKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PresentRegionKHR const& ) const = default; #else @@ -59098,15 +64930,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t rectangleCount = {}; const VULKAN_HPP_NAMESPACE::RectLayerKHR* pRectangles = {}; + }; static_assert( sizeof( PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PresentRegionKHR>::value, "struct wrapper is not a standard layout!" ); struct PresentRegionsKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentRegionsKHR; + VULKAN_HPP_CONSTEXPR PresentRegionsKHR( uint32_t swapchainCount_ = {}, const VULKAN_HPP_NAMESPACE::PresentRegionKHR* pRegions_ = {} ) VULKAN_HPP_NOEXCEPT : swapchainCount( swapchainCount_ ) @@ -59148,6 +64985,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPresentRegionsKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPresentRegionsKHR*>( this ); @@ -59158,6 +64996,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPresentRegionsKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PresentRegionsKHR const& ) const = default; #else @@ -59175,17 +65014,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePresentRegionsKHR; const void* pNext = {}; uint32_t swapchainCount = {}; const VULKAN_HPP_NAMESPACE::PresentRegionKHR* pRegions = {}; + }; static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PresentRegionsKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePresentRegionsKHR> + { + using Type = PresentRegionsKHR; + }; + struct PresentTimeGOOGLE { + VULKAN_HPP_CONSTEXPR PresentTimeGOOGLE( uint32_t presentID_ = {}, uint64_t desiredPresentTime_ = {} ) VULKAN_HPP_NOEXCEPT : presentID( presentID_ ) @@ -59215,6 +65064,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPresentTimeGOOGLE const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPresentTimeGOOGLE*>( this ); @@ -59225,6 +65075,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPresentTimeGOOGLE*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PresentTimeGOOGLE const& ) const = default; #else @@ -59240,15 +65091,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t presentID = {}; uint64_t desiredPresentTime = {}; + }; static_assert( sizeof( PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PresentTimeGOOGLE>::value, "struct wrapper is not a standard layout!" ); struct PresentTimesInfoGOOGLE { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentTimesInfoGOOGLE; + VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = {}, const VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE* pTimes_ = {} ) VULKAN_HPP_NOEXCEPT : swapchainCount( swapchainCount_ ) @@ -59290,6 +65146,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkPresentTimesInfoGOOGLE const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkPresentTimesInfoGOOGLE*>( this ); @@ -59300,6 +65157,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkPresentTimesInfoGOOGLE*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( PresentTimesInfoGOOGLE const& ) const = default; #else @@ -59317,17 +65175,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePresentTimesInfoGOOGLE; const void* pNext = {}; uint32_t swapchainCount = {}; const VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE* pTimes = {}; + }; static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<PresentTimesInfoGOOGLE>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::ePresentTimesInfoGOOGLE> + { + using Type = PresentTimesInfoGOOGLE; + }; + struct ProtectedSubmitInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eProtectedSubmitInfo; + VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( VULKAN_HPP_NAMESPACE::Bool32 protectedSubmit_ = {} ) VULKAN_HPP_NOEXCEPT : protectedSubmit( protectedSubmit_ ) {} @@ -59361,6 +65230,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkProtectedSubmitInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkProtectedSubmitInfo*>( this ); @@ -59371,6 +65241,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkProtectedSubmitInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ProtectedSubmitInfo const& ) const = default; #else @@ -59387,16 +65258,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eProtectedSubmitInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 protectedSubmit = {}; + }; static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ProtectedSubmitInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eProtectedSubmitInfo> + { + using Type = ProtectedSubmitInfo; + }; + struct QueryPoolCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolCreateInfo; + VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( VULKAN_HPP_NAMESPACE::QueryPoolCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::QueryType queryType_ = VULKAN_HPP_NAMESPACE::QueryType::eOcclusion, uint32_t queryCount_ = {}, @@ -59454,6 +65336,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkQueryPoolCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkQueryPoolCreateInfo*>( this ); @@ -59464,6 +65347,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkQueryPoolCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( QueryPoolCreateInfo const& ) const = default; #else @@ -59483,6 +65367,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueryPoolCreateInfo; const void* pNext = {}; @@ -59490,12 +65376,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::QueryType queryType = VULKAN_HPP_NAMESPACE::QueryType::eOcclusion; uint32_t queryCount = {}; VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags pipelineStatistics = {}; + }; static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<QueryPoolCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eQueryPoolCreateInfo> + { + using Type = QueryPoolCreateInfo; + }; + struct QueryPoolPerformanceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolPerformanceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR QueryPoolPerformanceCreateInfoKHR( uint32_t queueFamilyIndex_ = {}, uint32_t counterIndexCount_ = {}, const uint32_t* pCounterIndices_ = {} ) VULKAN_HPP_NOEXCEPT @@ -59545,6 +65440,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkQueryPoolPerformanceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>( this ); @@ -59555,6 +65451,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( QueryPoolPerformanceCreateInfoKHR const& ) const = default; #else @@ -59573,18 +65470,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueryPoolPerformanceCreateInfoKHR; const void* pNext = {}; uint32_t queueFamilyIndex = {}; uint32_t counterIndexCount = {}; const uint32_t* pCounterIndices = {}; + }; static_assert( sizeof( QueryPoolPerformanceCreateInfoKHR ) == sizeof( VkQueryPoolPerformanceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<QueryPoolPerformanceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eQueryPoolPerformanceCreateInfoKHR> + { + using Type = QueryPoolPerformanceCreateInfoKHR; + }; + struct QueryPoolPerformanceQueryCreateInfoINTEL { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL; + VULKAN_HPP_CONSTEXPR QueryPoolPerformanceQueryCreateInfoINTEL( VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL performanceCountersSampling_ = VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL::eManual ) VULKAN_HPP_NOEXCEPT : performanceCountersSampling( performanceCountersSampling_ ) {} @@ -59618,6 +65526,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkQueryPoolPerformanceQueryCreateInfoINTEL const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>( this ); @@ -59628,6 +65537,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( QueryPoolPerformanceQueryCreateInfoINTEL const& ) const = default; #else @@ -59644,16 +65554,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL; const void* pNext = {}; VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL performanceCountersSampling = VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL::eManual; + }; static_assert( sizeof( QueryPoolPerformanceQueryCreateInfoINTEL ) == sizeof( VkQueryPoolPerformanceQueryCreateInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<QueryPoolPerformanceQueryCreateInfoINTEL>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL> + { + using Type = QueryPoolPerformanceQueryCreateInfoINTEL; + }; + struct QueueFamilyCheckpointPropertiesNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyCheckpointPropertiesNV; + VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointPropertiesNV( VULKAN_HPP_NAMESPACE::PipelineStageFlags checkpointExecutionStageMask_ = {} ) VULKAN_HPP_NOEXCEPT : checkpointExecutionStageMask( checkpointExecutionStageMask_ ) {} @@ -59675,6 +65596,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkQueueFamilyCheckpointPropertiesNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>( this ); @@ -59685,6 +65607,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( QueueFamilyCheckpointPropertiesNV const& ) const = default; #else @@ -59701,16 +65624,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV; void* pNext = {}; VULKAN_HPP_NAMESPACE::PipelineStageFlags checkpointExecutionStageMask = {}; + }; static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<QueueFamilyCheckpointPropertiesNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eQueueFamilyCheckpointPropertiesNV> + { + using Type = QueueFamilyCheckpointPropertiesNV; + }; + struct QueueFamilyProperties { + VULKAN_HPP_CONSTEXPR QueueFamilyProperties( VULKAN_HPP_NAMESPACE::QueueFlags queueFlags_ = {}, uint32_t queueCount_ = {}, uint32_t timestampValidBits_ = {}, @@ -59732,6 +65665,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkQueueFamilyProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkQueueFamilyProperties*>( this ); @@ -59742,6 +65676,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkQueueFamilyProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( QueueFamilyProperties const& ) const = default; #else @@ -59759,17 +65694,22 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::QueueFlags queueFlags = {}; uint32_t queueCount = {}; uint32_t timestampValidBits = {}; VULKAN_HPP_NAMESPACE::Extent3D minImageTransferGranularity = {}; + }; static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<QueueFamilyProperties>::value, "struct wrapper is not a standard layout!" ); struct QueueFamilyProperties2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyProperties2; + VULKAN_HPP_CONSTEXPR QueueFamilyProperties2( VULKAN_HPP_NAMESPACE::QueueFamilyProperties queueFamilyProperties_ = {} ) VULKAN_HPP_NOEXCEPT : queueFamilyProperties( queueFamilyProperties_ ) {} @@ -59791,6 +65731,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkQueueFamilyProperties2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkQueueFamilyProperties2*>( this ); @@ -59801,6 +65742,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkQueueFamilyProperties2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( QueueFamilyProperties2 const& ) const = default; #else @@ -59817,17 +65759,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eQueueFamilyProperties2; void* pNext = {}; VULKAN_HPP_NAMESPACE::QueueFamilyProperties queueFamilyProperties = {}; + }; static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<QueueFamilyProperties2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eQueueFamilyProperties2> + { + using Type = QueueFamilyProperties2; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct RayTracingShaderGroupCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingShaderGroupCreateInfoKHR; + VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoKHR( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR type_ = VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR::eGeneral, uint32_t generalShader_ = {}, uint32_t closestHitShader_ = {}, @@ -59901,6 +65854,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRayTracingShaderGroupCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRayTracingShaderGroupCreateInfoKHR*>( this ); @@ -59911,6 +65865,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRayTracingShaderGroupCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RayTracingShaderGroupCreateInfoKHR const& ) const = default; #else @@ -59932,6 +65887,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoKHR; const void* pNext = {}; @@ -59941,14 +65898,23 @@ namespace VULKAN_HPP_NAMESPACE uint32_t anyHitShader = {}; uint32_t intersectionShader = {}; const void* pShaderGroupCaptureReplayHandle = {}; + }; static_assert( sizeof( RayTracingShaderGroupCreateInfoKHR ) == sizeof( VkRayTracingShaderGroupCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RayTracingShaderGroupCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eRayTracingShaderGroupCreateInfoKHR> + { + using Type = RayTracingShaderGroupCreateInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct RayTracingPipelineInterfaceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineInterfaceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR RayTracingPipelineInterfaceCreateInfoKHR( uint32_t maxPayloadSize_ = {}, uint32_t maxAttributeSize_ = {}, uint32_t maxCallableSize_ = {} ) VULKAN_HPP_NOEXCEPT @@ -59998,6 +65964,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRayTracingPipelineInterfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRayTracingPipelineInterfaceCreateInfoKHR*>( this ); @@ -60008,6 +65975,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRayTracingPipelineInterfaceCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RayTracingPipelineInterfaceCreateInfoKHR const& ) const = default; #else @@ -60026,20 +65994,31 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRayTracingPipelineInterfaceCreateInfoKHR; const void* pNext = {}; uint32_t maxPayloadSize = {}; uint32_t maxAttributeSize = {}; uint32_t maxCallableSize = {}; + }; static_assert( sizeof( RayTracingPipelineInterfaceCreateInfoKHR ) == sizeof( VkRayTracingPipelineInterfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RayTracingPipelineInterfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eRayTracingPipelineInterfaceCreateInfoKHR> + { + using Type = RayTracingPipelineInterfaceCreateInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct RayTracingPipelineCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineCreateInfoKHR; + VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoKHR( VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags_ = {}, uint32_t stageCount_ = {}, const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo* pStages_ = {}, @@ -60123,7 +66102,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - RayTracingPipelineCreateInfoKHR & setLibraries( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR libraries_ ) VULKAN_HPP_NOEXCEPT + RayTracingPipelineCreateInfoKHR & setLibraries( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & libraries_ ) VULKAN_HPP_NOEXCEPT { libraries = libraries_; return *this; @@ -60153,6 +66132,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRayTracingPipelineCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR*>( this ); @@ -60163,6 +66143,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRayTracingPipelineCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RayTracingPipelineCreateInfoKHR const& ) const = default; #else @@ -60189,6 +66170,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRayTracingPipelineCreateInfoKHR; const void* pNext = {}; @@ -60203,13 +66186,22 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PipelineLayout layout = {}; VULKAN_HPP_NAMESPACE::Pipeline basePipelineHandle = {}; int32_t basePipelineIndex = {}; + }; static_assert( sizeof( RayTracingPipelineCreateInfoKHR ) == sizeof( VkRayTracingPipelineCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RayTracingPipelineCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eRayTracingPipelineCreateInfoKHR> + { + using Type = RayTracingPipelineCreateInfoKHR; + }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ struct RayTracingShaderGroupCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingShaderGroupCreateInfoNV; + VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR type_ = VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR::eGeneral, uint32_t generalShader_ = {}, uint32_t closestHitShader_ = {}, @@ -60275,6 +66267,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRayTracingShaderGroupCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRayTracingShaderGroupCreateInfoNV*>( this ); @@ -60285,6 +66278,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RayTracingShaderGroupCreateInfoNV const& ) const = default; #else @@ -60305,6 +66299,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV; const void* pNext = {}; @@ -60313,12 +66309,21 @@ namespace VULKAN_HPP_NAMESPACE uint32_t closestHitShader = {}; uint32_t anyHitShader = {}; uint32_t intersectionShader = {}; + }; static_assert( sizeof( RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RayTracingShaderGroupCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eRayTracingShaderGroupCreateInfoNV> + { + using Type = RayTracingShaderGroupCreateInfoNV; + }; + struct RayTracingPipelineCreateInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineCreateInfoNV; + VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( VULKAN_HPP_NAMESPACE::PipelineCreateFlags flags_ = {}, uint32_t stageCount_ = {}, const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo* pStages_ = {}, @@ -60416,6 +66421,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRayTracingPipelineCreateInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( this ); @@ -60426,6 +66432,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RayTracingPipelineCreateInfoNV const& ) const = default; #else @@ -60450,6 +66457,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV; const void* pNext = {}; @@ -60462,12 +66471,20 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PipelineLayout layout = {}; VULKAN_HPP_NAMESPACE::Pipeline basePipelineHandle = {}; int32_t basePipelineIndex = {}; + }; static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RayTracingPipelineCreateInfoNV>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eRayTracingPipelineCreateInfoNV> + { + using Type = RayTracingPipelineCreateInfoNV; + }; + struct RefreshCycleDurationGOOGLE { + VULKAN_HPP_CONSTEXPR RefreshCycleDurationGOOGLE( uint64_t refreshDuration_ = {} ) VULKAN_HPP_NOEXCEPT : refreshDuration( refreshDuration_ ) {} @@ -60483,6 +66500,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRefreshCycleDurationGOOGLE const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRefreshCycleDurationGOOGLE*>( this ); @@ -60493,6 +66511,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RefreshCycleDurationGOOGLE const& ) const = default; #else @@ -60507,14 +66526,19 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint64_t refreshDuration = {}; + }; static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RefreshCycleDurationGOOGLE>::value, "struct wrapper is not a standard layout!" ); struct RenderPassAttachmentBeginInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassAttachmentBeginInfo; + VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfo( uint32_t attachmentCount_ = {}, const VULKAN_HPP_NAMESPACE::ImageView* pAttachments_ = {} ) VULKAN_HPP_NOEXCEPT : attachmentCount( attachmentCount_ ) @@ -60556,6 +66580,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRenderPassAttachmentBeginInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>( this ); @@ -60566,6 +66591,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRenderPassAttachmentBeginInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RenderPassAttachmentBeginInfo const& ) const = default; #else @@ -60583,17 +66609,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassAttachmentBeginInfo; const void* pNext = {}; uint32_t attachmentCount = {}; const VULKAN_HPP_NAMESPACE::ImageView* pAttachments = {}; + }; static_assert( sizeof( RenderPassAttachmentBeginInfo ) == sizeof( VkRenderPassAttachmentBeginInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RenderPassAttachmentBeginInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eRenderPassAttachmentBeginInfo> + { + using Type = RenderPassAttachmentBeginInfo; + }; + struct RenderPassBeginInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassBeginInfo; + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo( VULKAN_HPP_NAMESPACE::RenderPass renderPass_ = {}, VULKAN_HPP_NAMESPACE::Framebuffer framebuffer_ = {}, VULKAN_HPP_NAMESPACE::Rect2D renderArea_ = {}, @@ -60641,7 +66678,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - RenderPassBeginInfo & setRenderArea( VULKAN_HPP_NAMESPACE::Rect2D renderArea_ ) VULKAN_HPP_NOEXCEPT + RenderPassBeginInfo & setRenderArea( VULKAN_HPP_NAMESPACE::Rect2D const & renderArea_ ) VULKAN_HPP_NOEXCEPT { renderArea = renderArea_; return *this; @@ -60659,6 +66696,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRenderPassBeginInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRenderPassBeginInfo*>( this ); @@ -60669,6 +66707,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRenderPassBeginInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RenderPassBeginInfo const& ) const = default; #else @@ -60689,6 +66728,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassBeginInfo; const void* pNext = {}; @@ -60697,12 +66738,20 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Rect2D renderArea = {}; uint32_t clearValueCount = {}; const VULKAN_HPP_NAMESPACE::ClearValue* pClearValues = {}; + }; static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RenderPassBeginInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eRenderPassBeginInfo> + { + using Type = RenderPassBeginInfo; + }; + struct SubpassDescription { + VULKAN_HPP_CONSTEXPR SubpassDescription( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags_ = {}, VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics, uint32_t inputAttachmentCount_ = {}, @@ -60796,6 +66845,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSubpassDescription const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSubpassDescription*>( this ); @@ -60806,6 +66856,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSubpassDescription*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SubpassDescription const& ) const = default; #else @@ -60829,6 +66880,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags = {}; VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics; @@ -60840,12 +66893,14 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::AttachmentReference* pDepthStencilAttachment = {}; uint32_t preserveAttachmentCount = {}; const uint32_t* pPreserveAttachments = {}; + }; static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SubpassDescription>::value, "struct wrapper is not a standard layout!" ); struct SubpassDependency { + VULKAN_HPP_CONSTEXPR SubpassDependency( uint32_t srcSubpass_ = {}, uint32_t dstSubpass_ = {}, VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask_ = {}, @@ -60915,6 +66970,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSubpassDependency const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSubpassDependency*>( this ); @@ -60925,6 +66981,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSubpassDependency*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SubpassDependency const& ) const = default; #else @@ -60945,6 +67002,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t srcSubpass = {}; uint32_t dstSubpass = {}; @@ -60953,12 +67012,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::AccessFlags srcAccessMask = {}; VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask = {}; VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags = {}; + }; static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SubpassDependency>::value, "struct wrapper is not a standard layout!" ); struct RenderPassCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassCreateInfo; + VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags flags_ = {}, uint32_t attachmentCount_ = {}, const VULKAN_HPP_NAMESPACE::AttachmentDescription* pAttachments_ = {}, @@ -61040,6 +67102,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRenderPassCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRenderPassCreateInfo*>( this ); @@ -61050,6 +67113,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRenderPassCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RenderPassCreateInfo const& ) const = default; #else @@ -61072,6 +67136,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassCreateInfo; const void* pNext = {}; @@ -61082,12 +67148,21 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::SubpassDescription* pSubpasses = {}; uint32_t dependencyCount = {}; const VULKAN_HPP_NAMESPACE::SubpassDependency* pDependencies = {}; + }; static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RenderPassCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eRenderPassCreateInfo> + { + using Type = RenderPassCreateInfo; + }; + struct SubpassDescription2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassDescription2; + VULKAN_HPP_CONSTEXPR SubpassDescription2( VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags flags_ = {}, VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint_ = VULKAN_HPP_NAMESPACE::PipelineBindPoint::eGraphics, uint32_t viewMask_ = {}, @@ -61201,6 +67276,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSubpassDescription2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSubpassDescription2*>( this ); @@ -61211,6 +67287,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSubpassDescription2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SubpassDescription2 const& ) const = default; #else @@ -61237,6 +67314,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassDescription2; const void* pNext = {}; @@ -61251,12 +67330,21 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::AttachmentReference2* pDepthStencilAttachment = {}; uint32_t preserveAttachmentCount = {}; const uint32_t* pPreserveAttachments = {}; + }; static_assert( sizeof( SubpassDescription2 ) == sizeof( VkSubpassDescription2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SubpassDescription2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSubpassDescription2> + { + using Type = SubpassDescription2; + }; + struct SubpassDependency2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassDependency2; + VULKAN_HPP_CONSTEXPR SubpassDependency2( uint32_t srcSubpass_ = {}, uint32_t dstSubpass_ = {}, VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask_ = {}, @@ -61346,6 +67434,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSubpassDependency2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSubpassDependency2*>( this ); @@ -61356,6 +67445,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSubpassDependency2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SubpassDependency2 const& ) const = default; #else @@ -61379,6 +67469,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassDependency2; const void* pNext = {}; @@ -61390,12 +67482,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::AccessFlags dstAccessMask = {}; VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags = {}; int32_t viewOffset = {}; + }; static_assert( sizeof( SubpassDependency2 ) == sizeof( VkSubpassDependency2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SubpassDependency2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSubpassDependency2> + { + using Type = SubpassDependency2; + }; + struct RenderPassCreateInfo2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassCreateInfo2; + VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2( VULKAN_HPP_NAMESPACE::RenderPassCreateFlags flags_ = {}, uint32_t attachmentCount_ = {}, const VULKAN_HPP_NAMESPACE::AttachmentDescription2* pAttachments_ = {}, @@ -61493,6 +67594,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRenderPassCreateInfo2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRenderPassCreateInfo2*>( this ); @@ -61503,6 +67605,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRenderPassCreateInfo2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RenderPassCreateInfo2 const& ) const = default; #else @@ -61527,6 +67630,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassCreateInfo2; const void* pNext = {}; @@ -61539,12 +67644,21 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::SubpassDependency2* pDependencies = {}; uint32_t correlatedViewMaskCount = {}; const uint32_t* pCorrelatedViewMasks = {}; + }; static_assert( sizeof( RenderPassCreateInfo2 ) == sizeof( VkRenderPassCreateInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RenderPassCreateInfo2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eRenderPassCreateInfo2> + { + using Type = RenderPassCreateInfo2; + }; + struct RenderPassFragmentDensityMapCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT; + VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( VULKAN_HPP_NAMESPACE::AttachmentReference fragmentDensityMapAttachment_ = {} ) VULKAN_HPP_NOEXCEPT : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ ) {} @@ -61572,12 +67686,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - RenderPassFragmentDensityMapCreateInfoEXT & setFragmentDensityMapAttachment( VULKAN_HPP_NAMESPACE::AttachmentReference fragmentDensityMapAttachment_ ) VULKAN_HPP_NOEXCEPT + RenderPassFragmentDensityMapCreateInfoEXT & setFragmentDensityMapAttachment( VULKAN_HPP_NAMESPACE::AttachmentReference const & fragmentDensityMapAttachment_ ) VULKAN_HPP_NOEXCEPT { fragmentDensityMapAttachment = fragmentDensityMapAttachment_; return *this; } + operator VkRenderPassFragmentDensityMapCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>( this ); @@ -61588,6 +67703,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RenderPassFragmentDensityMapCreateInfoEXT const& ) const = default; #else @@ -61604,16 +67720,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::AttachmentReference fragmentDensityMapAttachment = {}; + }; static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RenderPassFragmentDensityMapCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eRenderPassFragmentDensityMapCreateInfoEXT> + { + using Type = RenderPassFragmentDensityMapCreateInfoEXT; + }; + struct RenderPassInputAttachmentAspectCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassInputAttachmentAspectCreateInfo; + VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = {}, const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference* pAspectReferences_ = {} ) VULKAN_HPP_NOEXCEPT : aspectReferenceCount( aspectReferenceCount_ ) @@ -61655,6 +67782,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRenderPassInputAttachmentAspectCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>( this ); @@ -61665,6 +67793,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RenderPassInputAttachmentAspectCreateInfo const& ) const = default; #else @@ -61682,17 +67811,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo; const void* pNext = {}; uint32_t aspectReferenceCount = {}; const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference* pAspectReferences = {}; + }; static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RenderPassInputAttachmentAspectCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eRenderPassInputAttachmentAspectCreateInfo> + { + using Type = RenderPassInputAttachmentAspectCreateInfo; + }; + struct RenderPassMultiviewCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassMultiviewCreateInfo; + VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = {}, const uint32_t* pViewMasks_ = {}, uint32_t dependencyCount_ = {}, @@ -61766,6 +67906,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRenderPassMultiviewCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>( this ); @@ -61776,6 +67917,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RenderPassMultiviewCreateInfo const& ) const = default; #else @@ -61797,6 +67939,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassMultiviewCreateInfo; const void* pNext = {}; @@ -61806,12 +67950,20 @@ namespace VULKAN_HPP_NAMESPACE const int32_t* pViewOffsets = {}; uint32_t correlationMaskCount = {}; const uint32_t* pCorrelationMasks = {}; + }; static_assert( sizeof( RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RenderPassMultiviewCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eRenderPassMultiviewCreateInfo> + { + using Type = RenderPassMultiviewCreateInfo; + }; + struct SubpassSampleLocationsEXT { + VULKAN_HPP_CONSTEXPR SubpassSampleLocationsEXT( uint32_t subpassIndex_ = {}, VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ = {} ) VULKAN_HPP_NOEXCEPT : subpassIndex( subpassIndex_ ) @@ -61835,12 +67987,13 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - SubpassSampleLocationsEXT & setSampleLocationsInfo( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo_ ) VULKAN_HPP_NOEXCEPT + SubpassSampleLocationsEXT & setSampleLocationsInfo( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfo_ ) VULKAN_HPP_NOEXCEPT { sampleLocationsInfo = sampleLocationsInfo_; return *this; } + operator VkSubpassSampleLocationsEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSubpassSampleLocationsEXT*>( this ); @@ -61851,6 +68004,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSubpassSampleLocationsEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SubpassSampleLocationsEXT const& ) const = default; #else @@ -61866,15 +68020,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t subpassIndex = {}; VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT sampleLocationsInfo = {}; + }; static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SubpassSampleLocationsEXT>::value, "struct wrapper is not a standard layout!" ); struct RenderPassSampleLocationsBeginInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassSampleLocationsBeginInfoEXT; + VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = {}, const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = {}, uint32_t postSubpassSampleLocationsCount_ = {}, @@ -61932,6 +68091,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRenderPassSampleLocationsBeginInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>( this ); @@ -61942,6 +68102,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RenderPassSampleLocationsBeginInfoEXT const& ) const = default; #else @@ -61961,6 +68122,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT; const void* pNext = {}; @@ -61968,12 +68131,21 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations = {}; uint32_t postSubpassSampleLocationsCount = {}; const VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT* pPostSubpassSampleLocations = {}; + }; static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RenderPassSampleLocationsBeginInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eRenderPassSampleLocationsBeginInfoEXT> + { + using Type = RenderPassSampleLocationsBeginInfoEXT; + }; + struct RenderPassTransformBeginInfoQCOM { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassTransformBeginInfoQCOM; + VULKAN_HPP_CONSTEXPR RenderPassTransformBeginInfoQCOM( VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR transform_ = VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR::eIdentity ) VULKAN_HPP_NOEXCEPT : transform( transform_ ) {} @@ -62007,6 +68179,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkRenderPassTransformBeginInfoQCOM const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>( this ); @@ -62017,6 +68190,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( RenderPassTransformBeginInfoQCOM const& ) const = default; #else @@ -62033,16 +68207,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassTransformBeginInfoQCOM; void* pNext = {}; VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR transform = VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR::eIdentity; + }; static_assert( sizeof( RenderPassTransformBeginInfoQCOM ) == sizeof( VkRenderPassTransformBeginInfoQCOM ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<RenderPassTransformBeginInfoQCOM>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eRenderPassTransformBeginInfoQCOM> + { + using Type = RenderPassTransformBeginInfoQCOM; + }; + struct SamplerCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerCreateInfo; + VULKAN_HPP_CONSTEXPR SamplerCreateInfo( VULKAN_HPP_NAMESPACE::SamplerCreateFlags flags_ = {}, VULKAN_HPP_NAMESPACE::Filter magFilter_ = VULKAN_HPP_NAMESPACE::Filter::eNearest, VULKAN_HPP_NAMESPACE::Filter minFilter_ = VULKAN_HPP_NAMESPACE::Filter::eNearest, @@ -62196,6 +68381,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSamplerCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSamplerCreateInfo*>( this ); @@ -62206,6 +68392,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSamplerCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SamplerCreateInfo const& ) const = default; #else @@ -62237,6 +68424,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSamplerCreateInfo; const void* pNext = {}; @@ -62256,12 +68445,21 @@ namespace VULKAN_HPP_NAMESPACE float maxLod = {}; VULKAN_HPP_NAMESPACE::BorderColor borderColor = VULKAN_HPP_NAMESPACE::BorderColor::eFloatTransparentBlack; VULKAN_HPP_NAMESPACE::Bool32 unnormalizedCoordinates = {}; + }; static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SamplerCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSamplerCreateInfo> + { + using Type = SamplerCreateInfo; + }; + struct SamplerReductionModeCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerReductionModeCreateInfo; + VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfo( VULKAN_HPP_NAMESPACE::SamplerReductionMode reductionMode_ = VULKAN_HPP_NAMESPACE::SamplerReductionMode::eWeightedAverage ) VULKAN_HPP_NOEXCEPT : reductionMode( reductionMode_ ) {} @@ -62295,6 +68493,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSamplerReductionModeCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSamplerReductionModeCreateInfo*>( this ); @@ -62305,6 +68504,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSamplerReductionModeCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SamplerReductionModeCreateInfo const& ) const = default; #else @@ -62321,16 +68521,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSamplerReductionModeCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::SamplerReductionMode reductionMode = VULKAN_HPP_NAMESPACE::SamplerReductionMode::eWeightedAverage; + }; static_assert( sizeof( SamplerReductionModeCreateInfo ) == sizeof( VkSamplerReductionModeCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SamplerReductionModeCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSamplerReductionModeCreateInfo> + { + using Type = SamplerReductionModeCreateInfo; + }; + struct SamplerYcbcrConversionCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionCreateInfo; + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion ycbcrModel_ = VULKAN_HPP_NAMESPACE::SamplerYcbcrModelConversion::eRgbIdentity, VULKAN_HPP_NAMESPACE::SamplerYcbcrRange ycbcrRange_ = VULKAN_HPP_NAMESPACE::SamplerYcbcrRange::eItuFull, @@ -62390,7 +68601,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - SamplerYcbcrConversionCreateInfo & setComponents( VULKAN_HPP_NAMESPACE::ComponentMapping components_ ) VULKAN_HPP_NOEXCEPT + SamplerYcbcrConversionCreateInfo & setComponents( VULKAN_HPP_NAMESPACE::ComponentMapping const & components_ ) VULKAN_HPP_NOEXCEPT { components = components_; return *this; @@ -62420,6 +68631,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSamplerYcbcrConversionCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( this ); @@ -62430,6 +68642,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SamplerYcbcrConversionCreateInfo const& ) const = default; #else @@ -62453,6 +68666,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo; const void* pNext = {}; @@ -62464,12 +68679,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ChromaLocation yChromaOffset = VULKAN_HPP_NAMESPACE::ChromaLocation::eCositedEven; VULKAN_HPP_NAMESPACE::Filter chromaFilter = VULKAN_HPP_NAMESPACE::Filter::eNearest; VULKAN_HPP_NAMESPACE::Bool32 forceExplicitReconstruction = {}; + }; static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SamplerYcbcrConversionCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSamplerYcbcrConversionCreateInfo> + { + using Type = SamplerYcbcrConversionCreateInfo; + }; + struct SamplerYcbcrConversionImageFormatProperties { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionImageFormatProperties; + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionImageFormatProperties( uint32_t combinedImageSamplerDescriptorCount_ = {} ) VULKAN_HPP_NOEXCEPT : combinedImageSamplerDescriptorCount( combinedImageSamplerDescriptorCount_ ) {} @@ -62491,6 +68715,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSamplerYcbcrConversionImageFormatProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>( this ); @@ -62501,6 +68726,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SamplerYcbcrConversionImageFormatProperties const& ) const = default; #else @@ -62517,16 +68743,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties; void* pNext = {}; uint32_t combinedImageSamplerDescriptorCount = {}; + }; static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SamplerYcbcrConversionImageFormatProperties>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSamplerYcbcrConversionImageFormatProperties> + { + using Type = SamplerYcbcrConversionImageFormatProperties; + }; + struct SamplerYcbcrConversionInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionInfo; + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion conversion_ = {} ) VULKAN_HPP_NOEXCEPT : conversion( conversion_ ) {} @@ -62560,6 +68797,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSamplerYcbcrConversionInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSamplerYcbcrConversionInfo*>( this ); @@ -62570,6 +68808,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSamplerYcbcrConversionInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SamplerYcbcrConversionInfo const& ) const = default; #else @@ -62586,16 +68825,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSamplerYcbcrConversionInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion conversion = {}; + }; static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SamplerYcbcrConversionInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSamplerYcbcrConversionInfo> + { + using Type = SamplerYcbcrConversionInfo; + }; + struct SemaphoreCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreCreateInfo; + VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) {} @@ -62629,6 +68879,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSemaphoreCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSemaphoreCreateInfo*>( this ); @@ -62639,6 +68890,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSemaphoreCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SemaphoreCreateInfo const& ) const = default; #else @@ -62655,16 +68907,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSemaphoreCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags flags = {}; + }; static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SemaphoreCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSemaphoreCreateInfo> + { + using Type = SemaphoreCreateInfo; + }; + struct SemaphoreGetFdInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreGetFdInfoKHR; + VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {}, VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT : semaphore( semaphore_ ) @@ -62706,6 +68969,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSemaphoreGetFdInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( this ); @@ -62716,6 +68980,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSemaphoreGetFdInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SemaphoreGetFdInfoKHR const& ) const = default; #else @@ -62733,18 +68998,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSemaphoreGetFdInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Semaphore semaphore = {}; VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; + }; static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SemaphoreGetFdInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSemaphoreGetFdInfoKHR> + { + using Type = SemaphoreGetFdInfoKHR; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct SemaphoreGetWin32HandleInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreGetWin32HandleInfoKHR; + VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {}, VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType_ = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT : semaphore( semaphore_ ) @@ -62786,6 +69062,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSemaphoreGetWin32HandleInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( this ); @@ -62796,6 +69073,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SemaphoreGetWin32HandleInfoKHR const& ) const = default; #else @@ -62813,18 +69091,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Semaphore semaphore = {}; VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits handleType = VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; + }; static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SemaphoreGetWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eSemaphoreGetWin32HandleInfoKHR> + { + using Type = SemaphoreGetWin32HandleInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct SemaphoreSignalInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreSignalInfo; + VULKAN_HPP_CONSTEXPR SemaphoreSignalInfo( VULKAN_HPP_NAMESPACE::Semaphore semaphore_ = {}, uint64_t value_ = {} ) VULKAN_HPP_NOEXCEPT : semaphore( semaphore_ ) @@ -62866,6 +69155,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSemaphoreSignalInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSemaphoreSignalInfo*>( this ); @@ -62876,6 +69166,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSemaphoreSignalInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SemaphoreSignalInfo const& ) const = default; #else @@ -62893,17 +69184,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSemaphoreSignalInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Semaphore semaphore = {}; uint64_t value = {}; + }; static_assert( sizeof( SemaphoreSignalInfo ) == sizeof( VkSemaphoreSignalInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SemaphoreSignalInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSemaphoreSignalInfo> + { + using Type = SemaphoreSignalInfo; + }; + struct SemaphoreTypeCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreTypeCreateInfo; + VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfo( VULKAN_HPP_NAMESPACE::SemaphoreType semaphoreType_ = VULKAN_HPP_NAMESPACE::SemaphoreType::eBinary, uint64_t initialValue_ = {} ) VULKAN_HPP_NOEXCEPT : semaphoreType( semaphoreType_ ) @@ -62945,6 +69247,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSemaphoreTypeCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSemaphoreTypeCreateInfo*>( this ); @@ -62955,6 +69258,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSemaphoreTypeCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SemaphoreTypeCreateInfo const& ) const = default; #else @@ -62972,17 +69276,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSemaphoreTypeCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::SemaphoreType semaphoreType = VULKAN_HPP_NAMESPACE::SemaphoreType::eBinary; uint64_t initialValue = {}; + }; static_assert( sizeof( SemaphoreTypeCreateInfo ) == sizeof( VkSemaphoreTypeCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SemaphoreTypeCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSemaphoreTypeCreateInfo> + { + using Type = SemaphoreTypeCreateInfo; + }; + struct SemaphoreWaitInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreWaitInfo; + VULKAN_HPP_CONSTEXPR SemaphoreWaitInfo( VULKAN_HPP_NAMESPACE::SemaphoreWaitFlags flags_ = {}, uint32_t semaphoreCount_ = {}, const VULKAN_HPP_NAMESPACE::Semaphore* pSemaphores_ = {}, @@ -63040,6 +69355,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSemaphoreWaitInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSemaphoreWaitInfo*>( this ); @@ -63050,6 +69366,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSemaphoreWaitInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SemaphoreWaitInfo const& ) const = default; #else @@ -63069,6 +69386,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSemaphoreWaitInfo; const void* pNext = {}; @@ -63076,12 +69395,20 @@ namespace VULKAN_HPP_NAMESPACE uint32_t semaphoreCount = {}; const VULKAN_HPP_NAMESPACE::Semaphore* pSemaphores = {}; const uint64_t* pValues = {}; + }; static_assert( sizeof( SemaphoreWaitInfo ) == sizeof( VkSemaphoreWaitInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SemaphoreWaitInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSemaphoreWaitInfo> + { + using Type = SemaphoreWaitInfo; + }; + struct SetStateFlagsIndirectCommandNV { + VULKAN_HPP_CONSTEXPR SetStateFlagsIndirectCommandNV( uint32_t data_ = {} ) VULKAN_HPP_NOEXCEPT : data( data_ ) {} @@ -63103,6 +69430,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSetStateFlagsIndirectCommandNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSetStateFlagsIndirectCommandNV*>( this ); @@ -63113,6 +69441,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSetStateFlagsIndirectCommandNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SetStateFlagsIndirectCommandNV const& ) const = default; #else @@ -63127,14 +69456,19 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t data = {}; + }; static_assert( sizeof( SetStateFlagsIndirectCommandNV ) == sizeof( VkSetStateFlagsIndirectCommandNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SetStateFlagsIndirectCommandNV>::value, "struct wrapper is not a standard layout!" ); struct ShaderModuleCreateInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderModuleCreateInfo; + VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags flags_ = {}, size_t codeSize_ = {}, const uint32_t* pCode_ = {} ) VULKAN_HPP_NOEXCEPT @@ -63184,6 +69518,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkShaderModuleCreateInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkShaderModuleCreateInfo*>( this ); @@ -63194,6 +69529,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkShaderModuleCreateInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ShaderModuleCreateInfo const& ) const = default; #else @@ -63212,18 +69548,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eShaderModuleCreateInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags flags = {}; size_t codeSize = {}; const uint32_t* pCode = {}; + }; static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ShaderModuleCreateInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eShaderModuleCreateInfo> + { + using Type = ShaderModuleCreateInfo; + }; + struct ShaderModuleValidationCacheCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderModuleValidationCacheCreateInfoEXT; + VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache_ = {} ) VULKAN_HPP_NOEXCEPT : validationCache( validationCache_ ) {} @@ -63257,6 +69604,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkShaderModuleValidationCacheCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>( this ); @@ -63267,6 +69615,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ShaderModuleValidationCacheCreateInfoEXT const& ) const = default; #else @@ -63283,16 +69632,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache = {}; + }; static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ShaderModuleValidationCacheCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eShaderModuleValidationCacheCreateInfoEXT> + { + using Type = ShaderModuleValidationCacheCreateInfoEXT; + }; + struct ShaderResourceUsageAMD { + VULKAN_HPP_CONSTEXPR ShaderResourceUsageAMD( uint32_t numUsedVgprs_ = {}, uint32_t numUsedSgprs_ = {}, uint32_t ldsSizePerLocalWorkGroup_ = {}, @@ -63316,6 +69675,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkShaderResourceUsageAMD const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkShaderResourceUsageAMD*>( this ); @@ -63326,6 +69686,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkShaderResourceUsageAMD*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ShaderResourceUsageAMD const& ) const = default; #else @@ -63344,18 +69705,22 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t numUsedVgprs = {}; uint32_t numUsedSgprs = {}; uint32_t ldsSizePerLocalWorkGroup = {}; size_t ldsUsageSizeInBytes = {}; size_t scratchMemUsageInBytes = {}; + }; static_assert( sizeof( ShaderResourceUsageAMD ) == sizeof( VkShaderResourceUsageAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ShaderResourceUsageAMD>::value, "struct wrapper is not a standard layout!" ); struct ShaderStatisticsInfoAMD { + VULKAN_HPP_CONSTEXPR_14 ShaderStatisticsInfoAMD( VULKAN_HPP_NAMESPACE::ShaderStageFlags shaderStageMask_ = {}, VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD resourceUsage_ = {}, uint32_t numPhysicalVgprs_ = {}, @@ -63383,6 +69748,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkShaderStatisticsInfoAMD const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkShaderStatisticsInfoAMD*>( this ); @@ -63393,6 +69759,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkShaderStatisticsInfoAMD*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ShaderStatisticsInfoAMD const& ) const = default; #else @@ -63413,6 +69780,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ShaderStageFlags shaderStageMask = {}; VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD resourceUsage = {}; @@ -63421,12 +69790,15 @@ namespace VULKAN_HPP_NAMESPACE uint32_t numAvailableVgprs = {}; uint32_t numAvailableSgprs = {}; VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> computeWorkGroupSize = {}; + }; static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ShaderStatisticsInfoAMD>::value, "struct wrapper is not a standard layout!" ); struct SharedPresentSurfaceCapabilitiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSharedPresentSurfaceCapabilitiesKHR; + VULKAN_HPP_CONSTEXPR SharedPresentSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::ImageUsageFlags sharedPresentSupportedUsageFlags_ = {} ) VULKAN_HPP_NOEXCEPT : sharedPresentSupportedUsageFlags( sharedPresentSupportedUsageFlags_ ) {} @@ -63448,6 +69820,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSharedPresentSurfaceCapabilitiesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>( this ); @@ -63458,6 +69831,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SharedPresentSurfaceCapabilitiesKHR const& ) const = default; #else @@ -63474,16 +69848,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR; void* pNext = {}; VULKAN_HPP_NAMESPACE::ImageUsageFlags sharedPresentSupportedUsageFlags = {}; + }; static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SharedPresentSurfaceCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSharedPresentSurfaceCapabilitiesKHR> + { + using Type = SharedPresentSurfaceCapabilitiesKHR; + }; + struct SparseImageFormatProperties { + VULKAN_HPP_CONSTEXPR SparseImageFormatProperties( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask_ = {}, VULKAN_HPP_NAMESPACE::Extent3D imageGranularity_ = {}, VULKAN_HPP_NAMESPACE::SparseImageFormatFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT @@ -63503,6 +69887,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSparseImageFormatProperties const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSparseImageFormatProperties*>( this ); @@ -63513,6 +69898,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSparseImageFormatProperties*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SparseImageFormatProperties const& ) const = default; #else @@ -63529,16 +69915,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {}; VULKAN_HPP_NAMESPACE::Extent3D imageGranularity = {}; VULKAN_HPP_NAMESPACE::SparseImageFormatFlags flags = {}; + }; static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SparseImageFormatProperties>::value, "struct wrapper is not a standard layout!" ); struct SparseImageFormatProperties2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSparseImageFormatProperties2; + VULKAN_HPP_CONSTEXPR SparseImageFormatProperties2( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties properties_ = {} ) VULKAN_HPP_NOEXCEPT : properties( properties_ ) {} @@ -63560,6 +69951,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSparseImageFormatProperties2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSparseImageFormatProperties2*>( this ); @@ -63570,6 +69962,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSparseImageFormatProperties2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SparseImageFormatProperties2 const& ) const = default; #else @@ -63586,16 +69979,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSparseImageFormatProperties2; void* pNext = {}; VULKAN_HPP_NAMESPACE::SparseImageFormatProperties properties = {}; + }; static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SparseImageFormatProperties2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSparseImageFormatProperties2> + { + using Type = SparseImageFormatProperties2; + }; + struct SparseImageMemoryRequirements { + VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties formatProperties_ = {}, uint32_t imageMipTailFirstLod_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize imageMipTailSize_ = {}, @@ -63619,6 +70022,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSparseImageMemoryRequirements const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSparseImageMemoryRequirements*>( this ); @@ -63629,6 +70033,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSparseImageMemoryRequirements*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SparseImageMemoryRequirements const& ) const = default; #else @@ -63647,18 +70052,23 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::SparseImageFormatProperties formatProperties = {}; uint32_t imageMipTailFirstLod = {}; VULKAN_HPP_NAMESPACE::DeviceSize imageMipTailSize = {}; VULKAN_HPP_NAMESPACE::DeviceSize imageMipTailOffset = {}; VULKAN_HPP_NAMESPACE::DeviceSize imageMipTailStride = {}; + }; static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SparseImageMemoryRequirements>::value, "struct wrapper is not a standard layout!" ); struct SparseImageMemoryRequirements2 { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSparseImageMemoryRequirements2; + VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements2( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements memoryRequirements_ = {} ) VULKAN_HPP_NOEXCEPT : memoryRequirements( memoryRequirements_ ) {} @@ -63680,6 +70090,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSparseImageMemoryRequirements2 const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSparseImageMemoryRequirements2*>( this ); @@ -63690,6 +70101,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSparseImageMemoryRequirements2*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SparseImageMemoryRequirements2 const& ) const = default; #else @@ -63706,17 +70118,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSparseImageMemoryRequirements2; void* pNext = {}; VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements memoryRequirements = {}; + }; static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SparseImageMemoryRequirements2>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSparseImageMemoryRequirements2> + { + using Type = SparseImageMemoryRequirements2; + }; + #ifdef VK_USE_PLATFORM_GGP struct StreamDescriptorSurfaceCreateInfoGGP { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP; + VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP flags_ = {}, GgpStreamDescriptor streamDescriptor_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -63758,6 +70181,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkStreamDescriptorSurfaceCreateInfoGGP const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>( this ); @@ -63768,6 +70192,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( StreamDescriptorSurfaceCreateInfoGGP const& ) const = default; #else @@ -63785,19 +70210,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP; const void* pNext = {}; VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP flags = {}; GgpStreamDescriptor streamDescriptor = {}; + }; static_assert( sizeof( StreamDescriptorSurfaceCreateInfoGGP ) == sizeof( VkStreamDescriptorSurfaceCreateInfoGGP ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<StreamDescriptorSurfaceCreateInfoGGP>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eStreamDescriptorSurfaceCreateInfoGGP> + { + using Type = StreamDescriptorSurfaceCreateInfoGGP; + }; #endif /*VK_USE_PLATFORM_GGP*/ #ifdef VK_ENABLE_BETA_EXTENSIONS struct StridedBufferRegionKHR { + VULKAN_HPP_CONSTEXPR StridedBufferRegionKHR( VULKAN_HPP_NAMESPACE::Buffer buffer_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize stride_ = {}, @@ -63852,6 +70287,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkStridedBufferRegionKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkStridedBufferRegionKHR*>( this ); @@ -63862,6 +70298,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkStridedBufferRegionKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( StridedBufferRegionKHR const& ) const = default; #else @@ -63879,11 +70316,14 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Buffer buffer = {}; VULKAN_HPP_NAMESPACE::DeviceSize offset = {}; VULKAN_HPP_NAMESPACE::DeviceSize stride = {}; VULKAN_HPP_NAMESPACE::DeviceSize size = {}; + }; static_assert( sizeof( StridedBufferRegionKHR ) == sizeof( VkStridedBufferRegionKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<StridedBufferRegionKHR>::value, "struct wrapper is not a standard layout!" ); @@ -63891,6 +70331,8 @@ namespace VULKAN_HPP_NAMESPACE struct SubmitInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubmitInfo; + VULKAN_HPP_CONSTEXPR SubmitInfo( uint32_t waitSemaphoreCount_ = {}, const VULKAN_HPP_NAMESPACE::Semaphore* pWaitSemaphores_ = {}, const VULKAN_HPP_NAMESPACE::PipelineStageFlags* pWaitDstStageMask_ = {}, @@ -63972,6 +70414,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSubmitInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSubmitInfo*>( this ); @@ -63982,6 +70425,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSubmitInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SubmitInfo const& ) const = default; #else @@ -64004,6 +70448,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubmitInfo; const void* pNext = {}; @@ -64014,12 +70460,21 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::CommandBuffer* pCommandBuffers = {}; uint32_t signalSemaphoreCount = {}; const VULKAN_HPP_NAMESPACE::Semaphore* pSignalSemaphores = {}; + }; static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SubmitInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSubmitInfo> + { + using Type = SubmitInfo; + }; + struct SubpassBeginInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassBeginInfo; + VULKAN_HPP_CONSTEXPR SubpassBeginInfo( VULKAN_HPP_NAMESPACE::SubpassContents contents_ = VULKAN_HPP_NAMESPACE::SubpassContents::eInline ) VULKAN_HPP_NOEXCEPT : contents( contents_ ) {} @@ -64053,6 +70508,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSubpassBeginInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSubpassBeginInfo*>( this ); @@ -64063,6 +70519,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSubpassBeginInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SubpassBeginInfo const& ) const = default; #else @@ -64079,16 +70536,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassBeginInfo; const void* pNext = {}; VULKAN_HPP_NAMESPACE::SubpassContents contents = VULKAN_HPP_NAMESPACE::SubpassContents::eInline; + }; static_assert( sizeof( SubpassBeginInfo ) == sizeof( VkSubpassBeginInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SubpassBeginInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSubpassBeginInfo> + { + using Type = SubpassBeginInfo; + }; + struct SubpassDescriptionDepthStencilResolve { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassDescriptionDepthStencilResolve; + VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolve( VULKAN_HPP_NAMESPACE::ResolveModeFlagBits depthResolveMode_ = VULKAN_HPP_NAMESPACE::ResolveModeFlagBits::eNone, VULKAN_HPP_NAMESPACE::ResolveModeFlagBits stencilResolveMode_ = VULKAN_HPP_NAMESPACE::ResolveModeFlagBits::eNone, const VULKAN_HPP_NAMESPACE::AttachmentReference2* pDepthStencilResolveAttachment_ = {} ) VULKAN_HPP_NOEXCEPT @@ -64138,6 +70606,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSubpassDescriptionDepthStencilResolve const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>( this ); @@ -64148,6 +70617,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SubpassDescriptionDepthStencilResolve const& ) const = default; #else @@ -64166,18 +70636,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassDescriptionDepthStencilResolve; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ResolveModeFlagBits depthResolveMode = VULKAN_HPP_NAMESPACE::ResolveModeFlagBits::eNone; VULKAN_HPP_NAMESPACE::ResolveModeFlagBits stencilResolveMode = VULKAN_HPP_NAMESPACE::ResolveModeFlagBits::eNone; const VULKAN_HPP_NAMESPACE::AttachmentReference2* pDepthStencilResolveAttachment = {}; + }; static_assert( sizeof( SubpassDescriptionDepthStencilResolve ) == sizeof( VkSubpassDescriptionDepthStencilResolve ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SubpassDescriptionDepthStencilResolve>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSubpassDescriptionDepthStencilResolve> + { + using Type = SubpassDescriptionDepthStencilResolve; + }; + struct SubpassEndInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassEndInfo; + VULKAN_HPP_CONSTEXPR SubpassEndInfo() VULKAN_HPP_NOEXCEPT {} @@ -64204,6 +70685,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSubpassEndInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSubpassEndInfo*>( this ); @@ -64214,6 +70696,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSubpassEndInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SubpassEndInfo const& ) const = default; #else @@ -64229,15 +70712,26 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassEndInfo; const void* pNext = {}; + }; static_assert( sizeof( SubpassEndInfo ) == sizeof( VkSubpassEndInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SubpassEndInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSubpassEndInfo> + { + using Type = SubpassEndInfo; + }; + struct SurfaceCapabilities2EXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilities2EXT; + VULKAN_HPP_CONSTEXPR SurfaceCapabilities2EXT( uint32_t minImageCount_ = {}, uint32_t maxImageCount_ = {}, VULKAN_HPP_NAMESPACE::Extent2D currentExtent_ = {}, @@ -64279,6 +70773,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSurfaceCapabilities2EXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSurfaceCapabilities2EXT*>( this ); @@ -64289,6 +70784,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSurfaceCapabilities2EXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SurfaceCapabilities2EXT const& ) const = default; #else @@ -64315,6 +70811,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSurfaceCapabilities2EXT; void* pNext = {}; @@ -64329,12 +70827,20 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR supportedCompositeAlpha = {}; VULKAN_HPP_NAMESPACE::ImageUsageFlags supportedUsageFlags = {}; VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT supportedSurfaceCounters = {}; + }; static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SurfaceCapabilities2EXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSurfaceCapabilities2EXT> + { + using Type = SurfaceCapabilities2EXT; + }; + struct SurfaceCapabilitiesKHR { + VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesKHR( uint32_t minImageCount_ = {}, uint32_t maxImageCount_ = {}, VULKAN_HPP_NAMESPACE::Extent2D currentExtent_ = {}, @@ -64368,6 +70874,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSurfaceCapabilitiesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>( this ); @@ -64378,6 +70885,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSurfaceCapabilitiesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SurfaceCapabilitiesKHR const& ) const = default; #else @@ -64401,6 +70909,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t minImageCount = {}; uint32_t maxImageCount = {}; @@ -64412,12 +70922,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR currentTransform = VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR::eIdentity; VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR supportedCompositeAlpha = {}; VULKAN_HPP_NAMESPACE::ImageUsageFlags supportedUsageFlags = {}; + }; static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SurfaceCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" ); struct SurfaceCapabilities2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilities2KHR; + VULKAN_HPP_CONSTEXPR SurfaceCapabilities2KHR( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities_ = {} ) VULKAN_HPP_NOEXCEPT : surfaceCapabilities( surfaceCapabilities_ ) {} @@ -64439,6 +70952,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSurfaceCapabilities2KHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSurfaceCapabilities2KHR*>( this ); @@ -64449,6 +70963,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSurfaceCapabilities2KHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SurfaceCapabilities2KHR const& ) const = default; #else @@ -64465,17 +70980,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSurfaceCapabilities2KHR; void* pNext = {}; VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities = {}; + }; static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SurfaceCapabilities2KHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSurfaceCapabilities2KHR> + { + using Type = SurfaceCapabilities2KHR; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct SurfaceCapabilitiesFullScreenExclusiveEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT; + VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( VULKAN_HPP_NAMESPACE::Bool32 fullScreenExclusiveSupported_ = {} ) VULKAN_HPP_NOEXCEPT : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ ) {} @@ -64509,6 +71035,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>( this ); @@ -64519,6 +71046,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SurfaceCapabilitiesFullScreenExclusiveEXT const& ) const = default; #else @@ -64535,17 +71063,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 fullScreenExclusiveSupported = {}; + }; static_assert( sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) == sizeof( VkSurfaceCapabilitiesFullScreenExclusiveEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SurfaceCapabilitiesFullScreenExclusiveEXT>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT> + { + using Type = SurfaceCapabilitiesFullScreenExclusiveEXT; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct SurfaceFormatKHR { + VULKAN_HPP_CONSTEXPR SurfaceFormatKHR( VULKAN_HPP_NAMESPACE::Format format_ = VULKAN_HPP_NAMESPACE::Format::eUndefined, VULKAN_HPP_NAMESPACE::ColorSpaceKHR colorSpace_ = VULKAN_HPP_NAMESPACE::ColorSpaceKHR::eSrgbNonlinear ) VULKAN_HPP_NOEXCEPT : format( format_ ) @@ -64563,6 +71101,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSurfaceFormatKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSurfaceFormatKHR*>( this ); @@ -64573,6 +71112,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSurfaceFormatKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SurfaceFormatKHR const& ) const = default; #else @@ -64588,15 +71128,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: VULKAN_HPP_NAMESPACE::Format format = VULKAN_HPP_NAMESPACE::Format::eUndefined; VULKAN_HPP_NAMESPACE::ColorSpaceKHR colorSpace = VULKAN_HPP_NAMESPACE::ColorSpaceKHR::eSrgbNonlinear; + }; static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SurfaceFormatKHR>::value, "struct wrapper is not a standard layout!" ); struct SurfaceFormat2KHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceFormat2KHR; + VULKAN_HPP_CONSTEXPR SurfaceFormat2KHR( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR surfaceFormat_ = {} ) VULKAN_HPP_NOEXCEPT : surfaceFormat( surfaceFormat_ ) {} @@ -64618,6 +71163,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSurfaceFormat2KHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSurfaceFormat2KHR*>( this ); @@ -64628,6 +71174,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSurfaceFormat2KHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SurfaceFormat2KHR const& ) const = default; #else @@ -64644,17 +71191,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSurfaceFormat2KHR; void* pNext = {}; VULKAN_HPP_NAMESPACE::SurfaceFormatKHR surfaceFormat = {}; + }; static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SurfaceFormat2KHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSurfaceFormat2KHR> + { + using Type = SurfaceFormat2KHR; + }; + #ifdef VK_USE_PLATFORM_WIN32_KHR struct SurfaceFullScreenExclusiveInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceFullScreenExclusiveInfoEXT; + VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT fullScreenExclusive_ = VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT::eDefault ) VULKAN_HPP_NOEXCEPT : fullScreenExclusive( fullScreenExclusive_ ) {} @@ -64688,6 +71246,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSurfaceFullScreenExclusiveInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>( this ); @@ -64698,6 +71257,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SurfaceFullScreenExclusiveInfoEXT const& ) const = default; #else @@ -64714,18 +71274,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT; void* pNext = {}; VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT fullScreenExclusive = VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT::eDefault; + }; static_assert( sizeof( SurfaceFullScreenExclusiveInfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SurfaceFullScreenExclusiveInfoEXT>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eSurfaceFullScreenExclusiveInfoEXT> + { + using Type = SurfaceFullScreenExclusiveInfoEXT; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR struct SurfaceFullScreenExclusiveWin32InfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT; + VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = {} ) VULKAN_HPP_NOEXCEPT : hmonitor( hmonitor_ ) {} @@ -64759,6 +71330,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSurfaceFullScreenExclusiveWin32InfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>( this ); @@ -64769,6 +71341,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SurfaceFullScreenExclusiveWin32InfoEXT const& ) const = default; #else @@ -64785,17 +71358,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT; const void* pNext = {}; HMONITOR hmonitor = {}; + }; static_assert( sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveWin32InfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SurfaceFullScreenExclusiveWin32InfoEXT>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT> + { + using Type = SurfaceFullScreenExclusiveWin32InfoEXT; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct SurfaceProtectedCapabilitiesKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceProtectedCapabilitiesKHR; + VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( VULKAN_HPP_NAMESPACE::Bool32 supportsProtected_ = {} ) VULKAN_HPP_NOEXCEPT : supportsProtected( supportsProtected_ ) {} @@ -64829,6 +71413,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSurfaceProtectedCapabilitiesKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>( this ); @@ -64839,6 +71424,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SurfaceProtectedCapabilitiesKHR const& ) const = default; #else @@ -64855,16 +71441,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 supportsProtected = {}; + }; static_assert( sizeof( SurfaceProtectedCapabilitiesKHR ) == sizeof( VkSurfaceProtectedCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SurfaceProtectedCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSurfaceProtectedCapabilitiesKHR> + { + using Type = SurfaceProtectedCapabilitiesKHR; + }; + struct SwapchainCounterCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainCounterCreateInfoEXT; + VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT surfaceCounters_ = {} ) VULKAN_HPP_NOEXCEPT : surfaceCounters( surfaceCounters_ ) {} @@ -64898,6 +71495,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSwapchainCounterCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>( this ); @@ -64908,6 +71506,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SwapchainCounterCreateInfoEXT const& ) const = default; #else @@ -64924,16 +71523,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT surfaceCounters = {}; + }; static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SwapchainCounterCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSwapchainCounterCreateInfoEXT> + { + using Type = SwapchainCounterCreateInfoEXT; + }; + struct SwapchainCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainCreateInfoKHR; + VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateFlagsKHR flags_ = {}, VULKAN_HPP_NAMESPACE::SurfaceKHR surface_ = {}, uint32_t minImageCount_ = {}, @@ -65021,7 +71631,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - SwapchainCreateInfoKHR & setImageExtent( VULKAN_HPP_NAMESPACE::Extent2D imageExtent_ ) VULKAN_HPP_NOEXCEPT + SwapchainCreateInfoKHR & setImageExtent( VULKAN_HPP_NAMESPACE::Extent2D const & imageExtent_ ) VULKAN_HPP_NOEXCEPT { imageExtent = imageExtent_; return *this; @@ -65087,6 +71697,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSwapchainCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSwapchainCreateInfoKHR*>( this ); @@ -65097,6 +71708,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSwapchainCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SwapchainCreateInfoKHR const& ) const = default; #else @@ -65128,6 +71740,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSwapchainCreateInfoKHR; const void* pNext = {}; @@ -65147,12 +71761,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PresentModeKHR presentMode = VULKAN_HPP_NAMESPACE::PresentModeKHR::eImmediate; VULKAN_HPP_NAMESPACE::Bool32 clipped = {}; VULKAN_HPP_NAMESPACE::SwapchainKHR oldSwapchain = {}; + }; static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SwapchainCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSwapchainCreateInfoKHR> + { + using Type = SwapchainCreateInfoKHR; + }; + struct SwapchainDisplayNativeHdrCreateInfoAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD; + VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable_ = {} ) VULKAN_HPP_NOEXCEPT : localDimmingEnable( localDimmingEnable_ ) {} @@ -65186,6 +71809,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkSwapchainDisplayNativeHdrCreateInfoAMD const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>( this ); @@ -65196,6 +71820,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( SwapchainDisplayNativeHdrCreateInfoAMD const& ) const = default; #else @@ -65212,16 +71837,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable = {}; + }; static_assert( sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) == sizeof( VkSwapchainDisplayNativeHdrCreateInfoAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<SwapchainDisplayNativeHdrCreateInfoAMD>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD> + { + using Type = SwapchainDisplayNativeHdrCreateInfoAMD; + }; + struct TextureLODGatherFormatPropertiesAMD { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTextureLodGatherFormatPropertiesAMD; + VULKAN_HPP_CONSTEXPR TextureLODGatherFormatPropertiesAMD( VULKAN_HPP_NAMESPACE::Bool32 supportsTextureGatherLODBiasAMD_ = {} ) VULKAN_HPP_NOEXCEPT : supportsTextureGatherLODBiasAMD( supportsTextureGatherLODBiasAMD_ ) {} @@ -65243,6 +71879,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkTextureLODGatherFormatPropertiesAMD const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>( this ); @@ -65253,6 +71890,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( TextureLODGatherFormatPropertiesAMD const& ) const = default; #else @@ -65269,16 +71907,27 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD; void* pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 supportsTextureGatherLODBiasAMD = {}; + }; static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<TextureLODGatherFormatPropertiesAMD>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eTextureLodGatherFormatPropertiesAMD> + { + using Type = TextureLODGatherFormatPropertiesAMD; + }; + struct TimelineSemaphoreSubmitInfo { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTimelineSemaphoreSubmitInfo; + VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfo( uint32_t waitSemaphoreValueCount_ = {}, const uint64_t* pWaitSemaphoreValues_ = {}, uint32_t signalSemaphoreValueCount_ = {}, @@ -65336,6 +71985,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkTimelineSemaphoreSubmitInfo const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>( this ); @@ -65346,6 +71996,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( TimelineSemaphoreSubmitInfo const& ) const = default; #else @@ -65365,6 +72016,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eTimelineSemaphoreSubmitInfo; const void* pNext = {}; @@ -65372,13 +72025,21 @@ namespace VULKAN_HPP_NAMESPACE const uint64_t* pWaitSemaphoreValues = {}; uint32_t signalSemaphoreValueCount = {}; const uint64_t* pSignalSemaphoreValues = {}; + }; static_assert( sizeof( TimelineSemaphoreSubmitInfo ) == sizeof( VkTimelineSemaphoreSubmitInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<TimelineSemaphoreSubmitInfo>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eTimelineSemaphoreSubmitInfo> + { + using Type = TimelineSemaphoreSubmitInfo; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS struct TraceRaysIndirectCommandKHR { + VULKAN_HPP_CONSTEXPR TraceRaysIndirectCommandKHR( uint32_t width_ = {}, uint32_t height_ = {}, uint32_t depth_ = {} ) VULKAN_HPP_NOEXCEPT @@ -65423,6 +72084,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkTraceRaysIndirectCommandKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkTraceRaysIndirectCommandKHR*>( this ); @@ -65433,6 +72095,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkTraceRaysIndirectCommandKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( TraceRaysIndirectCommandKHR const& ) const = default; #else @@ -65449,10 +72112,13 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: uint32_t width = {}; uint32_t height = {}; uint32_t depth = {}; + }; static_assert( sizeof( TraceRaysIndirectCommandKHR ) == sizeof( VkTraceRaysIndirectCommandKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<TraceRaysIndirectCommandKHR>::value, "struct wrapper is not a standard layout!" ); @@ -65460,6 +72126,8 @@ namespace VULKAN_HPP_NAMESPACE struct ValidationCacheCreateInfoEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationCacheCreateInfoEXT; + VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT flags_ = {}, size_t initialDataSize_ = {}, const void* pInitialData_ = {} ) VULKAN_HPP_NOEXCEPT @@ -65509,6 +72177,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkValidationCacheCreateInfoEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( this ); @@ -65519,6 +72188,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkValidationCacheCreateInfoEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ValidationCacheCreateInfoEXT const& ) const = default; #else @@ -65537,18 +72207,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eValidationCacheCreateInfoEXT; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT flags = {}; size_t initialDataSize = {}; const void* pInitialData = {}; + }; static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ValidationCacheCreateInfoEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eValidationCacheCreateInfoEXT> + { + using Type = ValidationCacheCreateInfoEXT; + }; + struct ValidationFeaturesEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationFeaturesEXT; + VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = {}, const VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = {}, uint32_t disabledValidationFeatureCount_ = {}, @@ -65606,6 +72287,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkValidationFeaturesEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkValidationFeaturesEXT*>( this ); @@ -65616,6 +72298,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkValidationFeaturesEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ValidationFeaturesEXT const& ) const = default; #else @@ -65635,6 +72318,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eValidationFeaturesEXT; const void* pNext = {}; @@ -65642,12 +72327,21 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT* pEnabledValidationFeatures = {}; uint32_t disabledValidationFeatureCount = {}; const VULKAN_HPP_NAMESPACE::ValidationFeatureDisableEXT* pDisabledValidationFeatures = {}; + }; static_assert( sizeof( ValidationFeaturesEXT ) == sizeof( VkValidationFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ValidationFeaturesEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eValidationFeaturesEXT> + { + using Type = ValidationFeaturesEXT; + }; + struct ValidationFlagsEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationFlagsEXT; + VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = {}, const VULKAN_HPP_NAMESPACE::ValidationCheckEXT* pDisabledValidationChecks_ = {} ) VULKAN_HPP_NOEXCEPT : disabledValidationCheckCount( disabledValidationCheckCount_ ) @@ -65689,6 +72383,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkValidationFlagsEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkValidationFlagsEXT*>( this ); @@ -65699,6 +72394,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkValidationFlagsEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ValidationFlagsEXT const& ) const = default; #else @@ -65716,18 +72412,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eValidationFlagsEXT; const void* pNext = {}; uint32_t disabledValidationCheckCount = {}; const VULKAN_HPP_NAMESPACE::ValidationCheckEXT* pDisabledValidationChecks = {}; + }; static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ValidationFlagsEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eValidationFlagsEXT> + { + using Type = ValidationFlagsEXT; + }; + #ifdef VK_USE_PLATFORM_VI_NN struct ViSurfaceCreateInfoNN { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eViSurfaceCreateInfoNN; + VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN flags_ = {}, void* window_ = {} ) VULKAN_HPP_NOEXCEPT : flags( flags_ ) @@ -65769,6 +72476,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkViSurfaceCreateInfoNN const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkViSurfaceCreateInfoNN*>( this ); @@ -65779,6 +72487,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkViSurfaceCreateInfoNN*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( ViSurfaceCreateInfoNN const& ) const = default; #else @@ -65796,19 +72505,30 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eViSurfaceCreateInfoNN; const void* pNext = {}; VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN flags = {}; void* window = {}; + }; static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<ViSurfaceCreateInfoNN>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eViSurfaceCreateInfoNN> + { + using Type = ViSurfaceCreateInfoNN; + }; #endif /*VK_USE_PLATFORM_VI_NN*/ #ifdef VK_USE_PLATFORM_WAYLAND_KHR struct WaylandSurfaceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWaylandSurfaceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR flags_ = {}, struct wl_display* display_ = {}, struct wl_surface* surface_ = {} ) VULKAN_HPP_NOEXCEPT @@ -65858,6 +72578,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkWaylandSurfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( this ); @@ -65868,6 +72589,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( WaylandSurfaceCreateInfoKHR const& ) const = default; #else @@ -65886,20 +72608,31 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR flags = {}; struct wl_display* display = {}; struct wl_surface* surface = {}; + }; static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<WaylandSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eWaylandSurfaceCreateInfoKHR> + { + using Type = WaylandSurfaceCreateInfoKHR; + }; #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR struct Win32KeyedMutexAcquireReleaseInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; + VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = {}, const VULKAN_HPP_NAMESPACE::DeviceMemory* pAcquireSyncs_ = {}, const uint64_t* pAcquireKeys_ = {}, @@ -65981,6 +72714,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkWin32KeyedMutexAcquireReleaseInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>( this ); @@ -65991,6 +72725,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( Win32KeyedMutexAcquireReleaseInfoKHR const& ) const = default; #else @@ -66013,6 +72748,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; const void* pNext = {}; @@ -66023,14 +72760,23 @@ namespace VULKAN_HPP_NAMESPACE uint32_t releaseCount = {}; const VULKAN_HPP_NAMESPACE::DeviceMemory* pReleaseSyncs = {}; const uint64_t* pReleaseKeys = {}; + }; static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<Win32KeyedMutexAcquireReleaseInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR> + { + using Type = Win32KeyedMutexAcquireReleaseInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR struct Win32KeyedMutexAcquireReleaseInfoNV { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; + VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = {}, const VULKAN_HPP_NAMESPACE::DeviceMemory* pAcquireSyncs_ = {}, const uint64_t* pAcquireKeys_ = {}, @@ -66112,6 +72858,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkWin32KeyedMutexAcquireReleaseInfoNV const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>( this ); @@ -66122,6 +72869,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( Win32KeyedMutexAcquireReleaseInfoNV const& ) const = default; #else @@ -66144,6 +72892,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; const void* pNext = {}; @@ -66154,14 +72904,23 @@ namespace VULKAN_HPP_NAMESPACE uint32_t releaseCount = {}; const VULKAN_HPP_NAMESPACE::DeviceMemory* pReleaseSyncs = {}; const uint64_t* pReleaseKeys = {}; + }; static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<Win32KeyedMutexAcquireReleaseInfoNV>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eWin32KeyedMutexAcquireReleaseInfoNV> + { + using Type = Win32KeyedMutexAcquireReleaseInfoNV; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR struct Win32SurfaceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWin32SurfaceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR flags_ = {}, HINSTANCE hinstance_ = {}, HWND hwnd_ = {} ) VULKAN_HPP_NOEXCEPT @@ -66211,6 +72970,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkWin32SurfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( this ); @@ -66221,6 +72981,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkWin32SurfaceCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( Win32SurfaceCreateInfoKHR const& ) const = default; #else @@ -66239,19 +73000,30 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR flags = {}; HINSTANCE hinstance = {}; HWND hwnd = {}; + }; static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<Win32SurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eWin32SurfaceCreateInfoKHR> + { + using Type = Win32SurfaceCreateInfoKHR; + }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct WriteDescriptorSet { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSet; + VULKAN_HPP_CONSTEXPR WriteDescriptorSet( VULKAN_HPP_NAMESPACE::DescriptorSet dstSet_ = {}, uint32_t dstBinding_ = {}, uint32_t dstArrayElement_ = {}, @@ -66341,6 +73113,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkWriteDescriptorSet const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkWriteDescriptorSet*>( this ); @@ -66351,6 +73124,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkWriteDescriptorSet*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( WriteDescriptorSet const& ) const = default; #else @@ -66374,6 +73148,8 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eWriteDescriptorSet; const void* pNext = {}; @@ -66385,12 +73161,21 @@ namespace VULKAN_HPP_NAMESPACE const VULKAN_HPP_NAMESPACE::DescriptorImageInfo* pImageInfo = {}; const VULKAN_HPP_NAMESPACE::DescriptorBufferInfo* pBufferInfo = {}; const VULKAN_HPP_NAMESPACE::BufferView* pTexelBufferView = {}; + }; static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<WriteDescriptorSet>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eWriteDescriptorSet> + { + using Type = WriteDescriptorSet; + }; + struct WriteDescriptorSetAccelerationStructureKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSetAccelerationStructureKHR; + VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureKHR( uint32_t accelerationStructureCount_ = {}, const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR* pAccelerationStructures_ = {} ) VULKAN_HPP_NOEXCEPT : accelerationStructureCount( accelerationStructureCount_ ) @@ -66432,6 +73217,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkWriteDescriptorSetAccelerationStructureKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>( this ); @@ -66442,6 +73228,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( WriteDescriptorSetAccelerationStructureKHR const& ) const = default; #else @@ -66459,17 +73246,28 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureKHR; const void* pNext = {}; uint32_t accelerationStructureCount = {}; const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR* pAccelerationStructures = {}; + }; static_assert( sizeof( WriteDescriptorSetAccelerationStructureKHR ) == sizeof( VkWriteDescriptorSetAccelerationStructureKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<WriteDescriptorSetAccelerationStructureKHR>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eWriteDescriptorSetAccelerationStructureKHR> + { + using Type = WriteDescriptorSetAccelerationStructureKHR; + }; + struct WriteDescriptorSetInlineUniformBlockEXT { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT; + VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = {}, const void* pData_ = {} ) VULKAN_HPP_NOEXCEPT : dataSize( dataSize_ ) @@ -66511,6 +73309,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkWriteDescriptorSetInlineUniformBlockEXT const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>( this ); @@ -66521,6 +73320,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( WriteDescriptorSetInlineUniformBlockEXT const& ) const = default; #else @@ -66538,18 +73338,29 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT; const void* pNext = {}; uint32_t dataSize = {}; const void* pData = {}; + }; static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<WriteDescriptorSetInlineUniformBlockEXT>::value, "struct wrapper is not a standard layout!" ); + template <> + struct CppType<StructureType, StructureType::eWriteDescriptorSetInlineUniformBlockEXT> + { + using Type = WriteDescriptorSetInlineUniformBlockEXT; + }; + #ifdef VK_USE_PLATFORM_XCB_KHR struct XcbSurfaceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eXcbSurfaceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR flags_ = {}, xcb_connection_t* connection_ = {}, xcb_window_t window_ = {} ) VULKAN_HPP_NOEXCEPT @@ -66599,6 +73410,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkXcbSurfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( this ); @@ -66609,6 +73421,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkXcbSurfaceCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( XcbSurfaceCreateInfoKHR const& ) const = default; #else @@ -66627,20 +73440,31 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR flags = {}; xcb_connection_t* connection = {}; xcb_window_t window = {}; + }; static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<XcbSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eXcbSurfaceCreateInfoKHR> + { + using Type = XcbSurfaceCreateInfoKHR; + }; #endif /*VK_USE_PLATFORM_XCB_KHR*/ #ifdef VK_USE_PLATFORM_XLIB_KHR struct XlibSurfaceCreateInfoKHR { + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eXlibSurfaceCreateInfoKHR; + VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR flags_ = {}, Display* dpy_ = {}, Window window_ = {} ) VULKAN_HPP_NOEXCEPT @@ -66690,6 +73514,7 @@ namespace VULKAN_HPP_NAMESPACE return *this; } + operator VkXlibSurfaceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( this ); @@ -66700,6 +73525,7 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast<VkXlibSurfaceCreateInfoKHR*>( this ); } + #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) auto operator<=>( XlibSurfaceCreateInfoKHR const& ) const = default; #else @@ -66718,15 +73544,24 @@ namespace VULKAN_HPP_NAMESPACE } #endif + + public: const VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR; const void* pNext = {}; VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR flags = {}; Display* dpy = {}; Window window = {}; + }; static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout<XlibSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" ); + + template <> + struct CppType<StructureType, StructureType::eXlibSurfaceCreateInfoKHR> + { + using Type = XlibSurfaceCreateInfoKHR; + }; #endif /*VK_USE_PLATFORM_XLIB_KHR*/ template<typename Dispatch> @@ -75941,6 +82776,9 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceRayTracingPropertiesNV>{ enum { value = true }; }; template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceRepresentativeFragmentTestFeaturesNV>{ enum { value = true }; }; template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceRepresentativeFragmentTestFeaturesNV>{ enum { value = true }; }; + template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceRobustness2FeaturesEXT>{ enum { value = true }; }; + template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceRobustness2FeaturesEXT>{ enum { value = true }; }; + template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceRobustness2PropertiesEXT>{ enum { value = true }; }; template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSampleLocationsPropertiesEXT>{ enum { value = true }; }; template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceSamplerFilterMinmaxProperties>{ enum { value = true }; }; template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDeviceSamplerYcbcrConversionFeatures>{ enum { value = true }; }; @@ -76171,6 +83009,7 @@ namespace VULKAN_HPP_NAMESPACE }; #endif + class DispatchLoaderDynamic { public: @@ -77681,6 +84520,7 @@ namespace VULKAN_HPP_NAMESPACE namespace std { + template <> struct hash<vk::AccelerationStructureKHR> { std::size_t operator()(vk::AccelerationStructureKHR const& accelerationStructureKHR) const VULKAN_HPP_NOEXCEPT |