From ba6cbb0478684580d6f6f3465d8b2c0ea594b642 Mon Sep 17 00:00:00 2001 From: Jon Leech Date: Mon, 18 Nov 2019 01:46:04 -0800 Subject: [PATCH] Update for Vulkan-Docs 1.1.128 --- include/vulkan/vulkan.hpp | 25433 +++++++++++++-------------------- include/vulkan/vulkan_core.h | 159 +- registry/validusage.json | 392 +- registry/vk.xml | 214 +- 4 files changed, 10371 insertions(+), 15827 deletions(-) diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index c56dc79..6caec20 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -56,11 +56,21 @@ # define VULKAN_HPP_ASSERT assert #endif -#if defined(__linux__) || defined(__APPLE__) -# include +#if !defined(VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL) +# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1 #endif -static_assert( VK_HEADER_VERSION == 127 , "Wrong VK_HEADER_VERSION!" ); +#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1 +# if defined(__linux__) || defined(__APPLE__) +# include +# endif + +# if defined(_WIN32) +# include +# endif +#endif + +static_assert( VK_HEADER_VERSION == 128 , "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 @@ -1161,6 +1171,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration ); } + VkResult vkAcquireProfilingLockKHR( VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAcquireProfilingLockKHR( device, pInfo ); + } + VkResult vkAllocateCommandBuffers( VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers ) const VULKAN_HPP_NOEXCEPT { return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers ); @@ -1928,6 +1943,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkReleasePerformanceConfigurationINTEL( device, configuration ); } + void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT + { + return ::vkReleaseProfilingLockKHR( device ); + } + VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT { return ::vkResetCommandPool( device, commandPool, flags ); @@ -2207,6 +2227,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties ); } + VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT + { + return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions ); + } + VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties ) const VULKAN_HPP_NOEXCEPT { return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties ); @@ -2387,6 +2412,11 @@ namespace VULKAN_HPP_NAMESPACE return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties ); } + void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( physicalDevice, pPerformanceQueryCreateInfo, pNumPasses ); + } + void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT { return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties ); @@ -4513,6 +4543,82 @@ namespace VULKAN_HPP_NAMESPACE } } + enum class PerformanceCounterScopeKHR + { + eVkQueryScopeCommandBuffer = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR, + eVkQueryScopeRenderPass = VK_QUERY_SCOPE_RENDER_PASS_KHR, + eVkQueryScopeCommand = VK_QUERY_SCOPE_COMMAND_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( PerformanceCounterScopeKHR value ) + { + switch ( value ) + { + case PerformanceCounterScopeKHR::eVkQueryScopeCommandBuffer : return "VkQueryScopeCommandBuffer"; + case PerformanceCounterScopeKHR::eVkQueryScopeRenderPass : return "VkQueryScopeRenderPass"; + case PerformanceCounterScopeKHR::eVkQueryScopeCommand : return "VkQueryScopeCommand"; + default: return "invalid"; + } + } + + enum class PerformanceCounterStorageKHR + { + eInt32 = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR, + eInt64 = VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR, + eUint32 = VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR, + eUint64 = VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR, + eFloat32 = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR, + eFloat64 = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( PerformanceCounterStorageKHR value ) + { + switch ( value ) + { + case PerformanceCounterStorageKHR::eInt32 : return "Int32"; + case PerformanceCounterStorageKHR::eInt64 : return "Int64"; + case PerformanceCounterStorageKHR::eUint32 : return "Uint32"; + case PerformanceCounterStorageKHR::eUint64 : return "Uint64"; + case PerformanceCounterStorageKHR::eFloat32 : return "Float32"; + case PerformanceCounterStorageKHR::eFloat64 : return "Float64"; + default: return "invalid"; + } + } + + enum class PerformanceCounterUnitKHR + { + eGeneric = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR, + ePercentage = VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR, + eNanoseconds = VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR, + eBytes = VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR, + eBytesPerSecond = VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR, + eKelvin = VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR, + eWatts = VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR, + eVolts = VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR, + eAmps = VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR, + eHertz = VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR, + eCycles = VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( PerformanceCounterUnitKHR value ) + { + switch ( value ) + { + case PerformanceCounterUnitKHR::eGeneric : return "Generic"; + case PerformanceCounterUnitKHR::ePercentage : return "Percentage"; + case PerformanceCounterUnitKHR::eNanoseconds : return "Nanoseconds"; + case PerformanceCounterUnitKHR::eBytes : return "Bytes"; + case PerformanceCounterUnitKHR::eBytesPerSecond : return "BytesPerSecond"; + case PerformanceCounterUnitKHR::eKelvin : return "Kelvin"; + case PerformanceCounterUnitKHR::eWatts : return "Watts"; + case PerformanceCounterUnitKHR::eVolts : return "Volts"; + case PerformanceCounterUnitKHR::eAmps : return "Amps"; + case PerformanceCounterUnitKHR::eHertz : return "Hertz"; + case PerformanceCounterUnitKHR::eCycles : return "Cycles"; + default: return "invalid"; + } + } + enum class PerformanceOverrideTypeINTEL { eNullHardware = VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL, @@ -4757,6 +4863,7 @@ namespace VULKAN_HPP_NAMESPACE ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS, eTimestamp = VK_QUERY_TYPE_TIMESTAMP, eTransformFeedbackStreamEXT = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT, + ePerformanceQueryKHR = VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, eAccelerationStructureCompactedSizeNV = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV, ePerformanceQueryINTEL = VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL }; @@ -4769,6 +4876,7 @@ namespace VULKAN_HPP_NAMESPACE case QueryType::ePipelineStatistics : return "PipelineStatistics"; case QueryType::eTimestamp : return "Timestamp"; case QueryType::eTransformFeedbackStreamEXT : return "TransformFeedbackStreamEXT"; + case QueryType::ePerformanceQueryKHR : return "PerformanceQueryKHR"; case QueryType::eAccelerationStructureCompactedSizeNV : return "AccelerationStructureCompactedSizeNV"; case QueryType::ePerformanceQueryINTEL : return "PerformanceQueryINTEL"; default: return "invalid"; @@ -5377,6 +5485,13 @@ namespace VULKAN_HPP_NAMESPACE eFenceGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR, eImportFenceFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, eFenceGetFdInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, + ePhysicalDevicePerformanceQueryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, + ePhysicalDevicePerformanceQueryPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR, + eQueryPoolPerformanceCreateInfoKHR = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR, + ePerformanceQuerySubmitInfoKHR = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR, + eAcquireProfilingLockInfoKHR = VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR, + ePerformanceCounterKHR = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR, + ePerformanceCounterDescriptionKHR = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR, ePhysicalDeviceSurfaceInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, eSurfaceCapabilities2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, eSurfaceFormat2KHR = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR, @@ -5832,6 +5947,13 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eFenceGetWin32HandleInfoKHR : return "FenceGetWin32HandleInfoKHR"; case StructureType::eImportFenceFdInfoKHR : return "ImportFenceFdInfoKHR"; case StructureType::eFenceGetFdInfoKHR : return "FenceGetFdInfoKHR"; + case StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR : return "PhysicalDevicePerformanceQueryFeaturesKHR"; + case StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR : return "PhysicalDevicePerformanceQueryPropertiesKHR"; + case StructureType::eQueryPoolPerformanceCreateInfoKHR : return "QueryPoolPerformanceCreateInfoKHR"; + case StructureType::ePerformanceQuerySubmitInfoKHR : return "PerformanceQuerySubmitInfoKHR"; + case StructureType::eAcquireProfilingLockInfoKHR : return "AcquireProfilingLockInfoKHR"; + case StructureType::ePerformanceCounterKHR : return "PerformanceCounterKHR"; + case StructureType::ePerformanceCounterDescriptionKHR : return "PerformanceCounterDescriptionKHR"; case StructureType::ePhysicalDeviceSurfaceInfo2KHR : return "PhysicalDeviceSurfaceInfo2KHR"; case StructureType::eSurfaceCapabilities2KHR : return "SurfaceCapabilities2KHR"; case StructureType::eSurfaceFormat2KHR : return "SurfaceFormat2KHR"; @@ -6367,6 +6489,21 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + enum class AcquireProfilingLockFlagBitsKHR + {}; + + VULKAN_HPP_INLINE std::string to_string( AcquireProfilingLockFlagBitsKHR ) + { + return "(void)"; + } + + using AcquireProfilingLockFlagsKHR = Flags; + + VULKAN_HPP_INLINE std::string to_string( AcquireProfilingLockFlagsKHR ) + { + return "{}"; + } + #ifdef VK_USE_PLATFORM_ANDROID_KHR enum class AndroidSurfaceCreateFlagBitsKHR {}; @@ -10090,6 +10227,72 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr(0, result.size() - 3) + " }"; } + enum class PerformanceCounterDescriptionFlagBitsKHR + { + ePerformanceImpacting = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR, + eConcurrentlyImpacted = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR + }; + + VULKAN_HPP_INLINE std::string to_string( PerformanceCounterDescriptionFlagBitsKHR value ) + { + switch ( value ) + { + case PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting : return "PerformanceImpacting"; + case PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted : return "ConcurrentlyImpacted"; + default: return "invalid"; + } + } + + using PerformanceCounterDescriptionFlagsKHR = Flags; + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting) | VkFlags(PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted) + }; + }; + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR operator|( PerformanceCounterDescriptionFlagBitsKHR bit0, PerformanceCounterDescriptionFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT + { + return PerformanceCounterDescriptionFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR operator&( PerformanceCounterDescriptionFlagBitsKHR bit0, PerformanceCounterDescriptionFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT + { + return PerformanceCounterDescriptionFlagsKHR( bit0 ) & bit1; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR operator^( PerformanceCounterDescriptionFlagBitsKHR bit0, PerformanceCounterDescriptionFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT + { + return PerformanceCounterDescriptionFlagsKHR( bit0 ) ^ bit1; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR PerformanceCounterDescriptionFlagsKHR operator~( PerformanceCounterDescriptionFlagBitsKHR bits ) VULKAN_HPP_NOEXCEPT + { + return ~( PerformanceCounterDescriptionFlagsKHR( bits ) ); + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator==( PerformanceCounterDescriptionFlagBitsKHR bit0, PerformanceCounterDescriptionFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT + { + return PerformanceCounterDescriptionFlagsKHR( bit0 ) == bit1; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR bool operator!=( PerformanceCounterDescriptionFlagBitsKHR bit0, PerformanceCounterDescriptionFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT + { + return PerformanceCounterDescriptionFlagsKHR( bit0 ) != bit1; + } + + VULKAN_HPP_INLINE std::string to_string( PerformanceCounterDescriptionFlagsKHR value ) + { + if ( !value ) return "{}"; + std::string result; + + if ( value & PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting ) result += "PerformanceImpacting | "; + if ( value & PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted ) result += "ConcurrentlyImpacted | "; + return "{ " + result.substr(0, result.size() - 3) + " }"; + } + enum class PipelineCacheCreateFlagBits {}; @@ -10186,7 +10389,7 @@ namespace VULKAN_HPP_NAMESPACE eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT, eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, - eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE, + eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV, eCaptureStatisticsKHR = VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR, eCaptureInternalRepresentationsKHR = VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR, @@ -12572,7 +12775,7 @@ namespace VULKAN_HPP_NAMESPACE : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {} }; - VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) + [[noreturn]] static void throwResultException( Result result, char const * message ) { switch ( result ) { @@ -12736,6 +12939,7 @@ namespace VULKAN_HPP_NAMESPACE struct AccelerationStructureInfoNV; struct AccelerationStructureMemoryRequirementsInfoNV; struct AcquireNextImageInfoKHR; + struct AcquireProfilingLockInfoKHR; struct AllocationCallbacks; #ifdef VK_USE_PLATFORM_ANDROID_KHR struct AndroidHardwareBufferFormatPropertiesANDROID; @@ -13046,8 +13250,12 @@ namespace VULKAN_HPP_NAMESPACE struct Offset3D; struct PastPresentationTimingGOOGLE; struct PerformanceConfigurationAcquireInfoINTEL; + struct PerformanceCounterDescriptionKHR; + struct PerformanceCounterKHR; + union PerformanceCounterResultKHR; struct PerformanceMarkerInfoINTEL; struct PerformanceOverrideInfoINTEL; + struct PerformanceQuerySubmitInfoKHR; struct PerformanceStreamMarkerInfoINTEL; union PerformanceValueDataINTEL; struct PerformanceValueINTEL; @@ -13123,6 +13331,8 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceMultiviewProperties; using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; struct PhysicalDevicePCIBusInfoPropertiesEXT; + struct PhysicalDevicePerformanceQueryFeaturesKHR; + struct PhysicalDevicePerformanceQueryPropertiesKHR; struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; struct PhysicalDevicePointClippingProperties; using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties; @@ -13234,6 +13444,7 @@ namespace VULKAN_HPP_NAMESPACE struct PushConstantRange; struct QueryPoolCreateInfo; struct QueryPoolCreateInfoINTEL; + struct QueryPoolPerformanceCreateInfoKHR; struct QueueFamilyCheckpointPropertiesNV; struct QueueFamilyProperties; struct QueueFamilyProperties2; @@ -16592,6 +16803,13 @@ namespace VULKAN_HPP_NAMESPACE ResultValueType::type acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + Result acquireProfilingLockKHR( const vk::AcquireProfilingLockInfoKHR* pInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + ResultValueType::type acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template Result allocateCommandBuffers( const vk::CommandBufferAllocateInfo* pAllocateInfo, vk::CommandBuffer* pCommandBuffers, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -18027,6 +18245,10 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template ResultValueType::type registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + typename ResultValueType>::type registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo, Optional allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -18034,6 +18256,10 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template ResultValueType::type registerDisplayEventEXT( vk::DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + typename ResultValueType>::type registerDisplayEventEXTUnique( vk::DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -18061,6 +18287,9 @@ namespace VULKAN_HPP_NAMESPACE ResultValueType::type releasePerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + void releaseProfilingLockKHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT; + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template Result resetCommandPool( vk::CommandPool commandPool, vk::CommandPoolResetFlags flags, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; @@ -18380,6 +18609,15 @@ namespace VULKAN_HPP_NAMESPACE typename ResultValueType>::type enumerateDeviceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + Result enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, uint32_t* pCounterCount, vk::PerformanceCounterKHR* pCounters, vk::PerformanceCounterDescriptionKHR* pCounterDescriptions, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + typename ResultValueType>::type enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, ArrayProxy counters, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; + template, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + typename ResultValueType>::type enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, ArrayProxy counters, Allocator const& vectorAllocator, Dispatch const &d ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template Result getDisplayModeProperties2KHR( vk::DisplayKHR display, uint32_t* pPropertyCount, vk::DisplayModeProperties2KHR* pProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -18672,6 +18910,13 @@ namespace VULKAN_HPP_NAMESPACE StructureChain getProperties2KHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + void getQueueFamilyPerformanceQueryPassesKHR( const vk::QueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + uint32_t getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -19296,65 +19541,7 @@ namespace VULKAN_HPP_NAMESPACE ResultValueType::type enumerateInstanceVersion(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ); #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - namespace layout - { - struct GeometryTrianglesNV - { - protected: - VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( vk::Buffer vertexData_ = vk::Buffer(), - vk::DeviceSize vertexOffset_ = 0, - uint32_t vertexCount_ = 0, - vk::DeviceSize vertexStride_ = 0, - vk::Format vertexFormat_ = vk::Format::eUndefined, - vk::Buffer indexData_ = vk::Buffer(), - vk::DeviceSize indexOffset_ = 0, - uint32_t indexCount_ = 0, - vk::IndexType indexType_ = vk::IndexType::eUint16, - vk::Buffer transformData_ = vk::Buffer(), - vk::DeviceSize transformOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : vertexData( vertexData_ ) - , vertexOffset( vertexOffset_ ) - , vertexCount( vertexCount_ ) - , vertexStride( vertexStride_ ) - , vertexFormat( vertexFormat_ ) - , indexData( indexData_ ) - , indexOffset( indexOffset_ ) - , indexCount( indexCount_ ) - , indexType( indexType_ ) - , transformData( transformData_ ) - , transformOffset( transformOffset_ ) - {} - - GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eGeometryTrianglesNV; - const void* pNext = nullptr; - vk::Buffer vertexData; - vk::DeviceSize vertexOffset; - uint32_t vertexCount; - vk::DeviceSize vertexStride; - vk::Format vertexFormat; - vk::Buffer indexData; - vk::DeviceSize indexOffset; - uint32_t indexCount; - vk::IndexType indexType; - vk::Buffer transformData; - vk::DeviceSize transformOffset; - }; - static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "layout struct and wrapper have different size!" ); - } - - struct GeometryTrianglesNV : public layout::GeometryTrianglesNV + struct GeometryTrianglesNV { VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( vk::Buffer vertexData_ = vk::Buffer(), vk::DeviceSize vertexOffset_ = 0, @@ -19367,16 +19554,33 @@ namespace VULKAN_HPP_NAMESPACE vk::IndexType indexType_ = vk::IndexType::eUint16, vk::Buffer transformData_ = vk::Buffer(), vk::DeviceSize transformOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::GeometryTrianglesNV( vertexData_, vertexOffset_, vertexCount_, vertexStride_, vertexFormat_, indexData_, indexOffset_, indexCount_, indexType_, transformData_, transformOffset_ ) + : vertexData( vertexData_ ) + , vertexOffset( vertexOffset_ ) + , vertexCount( vertexCount_ ) + , vertexStride( vertexStride_ ) + , vertexFormat( vertexFormat_ ) + , indexData( indexData_ ) + , indexOffset( indexOffset_ ) + , indexCount( indexCount_ ) + , indexType( indexType_ ) + , transformData( transformData_ ) + , transformOffset( transformOffset_ ) {} + vk::GeometryTrianglesNV & operator=( vk::GeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::GeometryTrianglesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::GeometryTrianglesNV( rhs ) - {} + { + *this = rhs; + } GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::GeometryTrianglesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -19484,65 +19688,50 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::GeometryTrianglesNV::sType; + public: + const vk::StructureType sType = StructureType::eGeometryTrianglesNV; + const void* pNext = nullptr; + vk::Buffer vertexData; + vk::DeviceSize vertexOffset; + uint32_t vertexCount; + vk::DeviceSize vertexStride; + vk::Format vertexFormat; + vk::Buffer indexData; + vk::DeviceSize indexOffset; + uint32_t indexCount; + vk::IndexType indexType; + vk::Buffer transformData; + vk::DeviceSize transformOffset; }; static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct GeometryAABBNV - { - protected: - VULKAN_HPP_CONSTEXPR GeometryAABBNV( vk::Buffer aabbData_ = vk::Buffer(), - uint32_t numAABBs_ = 0, - uint32_t stride_ = 0, - vk::DeviceSize offset_ = 0 ) VULKAN_HPP_NOEXCEPT - : aabbData( aabbData_ ) - , numAABBs( numAABBs_ ) - , stride( stride_ ) - , offset( offset_ ) - {} - - GeometryAABBNV( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eGeometryAabbNV; - const void* pNext = nullptr; - vk::Buffer aabbData; - uint32_t numAABBs; - uint32_t stride; - vk::DeviceSize offset; - }; - static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "layout struct and wrapper have different size!" ); - } - - struct GeometryAABBNV : public layout::GeometryAABBNV + struct GeometryAABBNV { VULKAN_HPP_CONSTEXPR GeometryAABBNV( vk::Buffer aabbData_ = vk::Buffer(), uint32_t numAABBs_ = 0, uint32_t stride_ = 0, vk::DeviceSize offset_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::GeometryAABBNV( aabbData_, numAABBs_, stride_, offset_ ) + : aabbData( aabbData_ ) + , numAABBs( numAABBs_ ) + , stride( stride_ ) + , offset( offset_ ) {} + vk::GeometryAABBNV & operator=( vk::GeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::GeometryAABBNV ) - sizeof( vk::StructureType ) ); + return *this; + } + GeometryAABBNV( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::GeometryAABBNV( rhs ) - {} + { + *this = rhs; + } GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::GeometryAABBNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -19601,8 +19790,13 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::GeometryAABBNV::sType; + public: + const vk::StructureType sType = StructureType::eGeometryAabbNV; + const void* pNext = nullptr; + vk::Buffer aabbData; + uint32_t numAABBs; + uint32_t stride; + vk::DeviceSize offset; }; static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -19617,12 +19811,12 @@ namespace VULKAN_HPP_NAMESPACE GeometryDataNV( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } GeometryDataNV& operator=( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -19666,55 +19860,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( GeometryDataNV ) == sizeof( VkGeometryDataNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct GeometryNV - { - protected: - VULKAN_HPP_CONSTEXPR GeometryNV( vk::GeometryTypeNV geometryType_ = vk::GeometryTypeNV::eTriangles, - vk::GeometryDataNV geometry_ = vk::GeometryDataNV(), - vk::GeometryFlagsNV flags_ = vk::GeometryFlagsNV() ) VULKAN_HPP_NOEXCEPT - : geometryType( geometryType_ ) - , geometry( geometry_ ) - , flags( flags_ ) - {} - - GeometryNV( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - GeometryNV& operator=( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eGeometryNV; - const void* pNext = nullptr; - vk::GeometryTypeNV geometryType; - vk::GeometryDataNV geometry; - vk::GeometryFlagsNV flags; - }; - static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "layout struct and wrapper have different size!" ); - } - - struct GeometryNV : public layout::GeometryNV + struct GeometryNV { VULKAN_HPP_CONSTEXPR GeometryNV( vk::GeometryTypeNV geometryType_ = vk::GeometryTypeNV::eTriangles, vk::GeometryDataNV geometry_ = vk::GeometryDataNV(), vk::GeometryFlagsNV flags_ = vk::GeometryFlagsNV() ) VULKAN_HPP_NOEXCEPT - : layout::GeometryNV( geometryType_, geometry_, flags_ ) + : geometryType( geometryType_ ) + , geometry( geometry_ ) + , flags( flags_ ) {} + vk::GeometryNV & operator=( vk::GeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::GeometryNV ) - sizeof( vk::StructureType ) ); + return *this; + } + GeometryNV( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::GeometryNV( rhs ) - {} + { + *this = rhs; + } GeometryNV& operator=( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::GeometryNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -19766,69 +19935,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::GeometryNV::sType; + public: + const vk::StructureType sType = StructureType::eGeometryNV; + const void* pNext = nullptr; + vk::GeometryTypeNV geometryType; + vk::GeometryDataNV geometry; + vk::GeometryFlagsNV flags; }; static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct AccelerationStructureInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( vk::AccelerationStructureTypeNV type_ = vk::AccelerationStructureTypeNV::eTopLevel, - vk::BuildAccelerationStructureFlagsNV flags_ = vk::BuildAccelerationStructureFlagsNV(), - uint32_t instanceCount_ = 0, - uint32_t geometryCount_ = 0, - const vk::GeometryNV* pGeometries_ = nullptr ) VULKAN_HPP_NOEXCEPT - : type( type_ ) - , flags( flags_ ) - , instanceCount( instanceCount_ ) - , geometryCount( geometryCount_ ) - , pGeometries( pGeometries_ ) - {} - - AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAccelerationStructureInfoNV; - const void* pNext = nullptr; - vk::AccelerationStructureTypeNV type; - vk::BuildAccelerationStructureFlagsNV flags; - uint32_t instanceCount; - uint32_t geometryCount; - const vk::GeometryNV* pGeometries; - }; - static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct AccelerationStructureInfoNV : public layout::AccelerationStructureInfoNV + struct AccelerationStructureInfoNV { VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( vk::AccelerationStructureTypeNV type_ = vk::AccelerationStructureTypeNV::eTopLevel, vk::BuildAccelerationStructureFlagsNV flags_ = vk::BuildAccelerationStructureFlagsNV(), uint32_t instanceCount_ = 0, uint32_t geometryCount_ = 0, const vk::GeometryNV* pGeometries_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::AccelerationStructureInfoNV( type_, flags_, instanceCount_, geometryCount_, pGeometries_ ) + : type( type_ ) + , flags( flags_ ) + , instanceCount( instanceCount_ ) + , geometryCount( geometryCount_ ) + , pGeometries( pGeometries_ ) {} + vk::AccelerationStructureInfoNV & operator=( vk::AccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AccelerationStructureInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AccelerationStructureInfoNV( rhs ) - {} + { + *this = rhs; + } AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AccelerationStructureInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -19894,57 +20038,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AccelerationStructureInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eAccelerationStructureInfoNV; + const void* pNext = nullptr; + vk::AccelerationStructureTypeNV type; + vk::BuildAccelerationStructureFlagsNV flags; + uint32_t instanceCount; + uint32_t geometryCount; + const vk::GeometryNV* pGeometries; }; static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct AccelerationStructureCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( vk::DeviceSize compactedSize_ = 0, - vk::AccelerationStructureInfoNV info_ = vk::AccelerationStructureInfoNV() ) VULKAN_HPP_NOEXCEPT - : compactedSize( compactedSize_ ) - , info( info_ ) - {} - - AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAccelerationStructureCreateInfoNV; - const void* pNext = nullptr; - vk::DeviceSize compactedSize; - vk::AccelerationStructureInfoNV info; - }; - static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct AccelerationStructureCreateInfoNV : public layout::AccelerationStructureCreateInfoNV + struct AccelerationStructureCreateInfoNV { VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( vk::DeviceSize compactedSize_ = 0, vk::AccelerationStructureInfoNV info_ = vk::AccelerationStructureInfoNV() ) VULKAN_HPP_NOEXCEPT - : layout::AccelerationStructureCreateInfoNV( compactedSize_, info_ ) + : compactedSize( compactedSize_ ) + , info( info_ ) {} + vk::AccelerationStructureCreateInfoNV & operator=( vk::AccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AccelerationStructureCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AccelerationStructureCreateInfoNV( rhs ) - {} + { + *this = rhs; + } AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AccelerationStructureCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -19989,57 +20116,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AccelerationStructureCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eAccelerationStructureCreateInfoNV; + const void* pNext = nullptr; + vk::DeviceSize compactedSize; + vk::AccelerationStructureInfoNV info; }; static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct AccelerationStructureMemoryRequirementsInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( vk::AccelerationStructureMemoryRequirementsTypeNV type_ = vk::AccelerationStructureMemoryRequirementsTypeNV::eObject, - vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV() ) VULKAN_HPP_NOEXCEPT - : type( type_ ) - , accelerationStructure( accelerationStructure_ ) - {} - - AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV; - const void* pNext = nullptr; - vk::AccelerationStructureMemoryRequirementsTypeNV type; - vk::AccelerationStructureNV accelerationStructure; - }; - static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct AccelerationStructureMemoryRequirementsInfoNV : public layout::AccelerationStructureMemoryRequirementsInfoNV + struct AccelerationStructureMemoryRequirementsInfoNV { VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( vk::AccelerationStructureMemoryRequirementsTypeNV type_ = vk::AccelerationStructureMemoryRequirementsTypeNV::eObject, vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV() ) VULKAN_HPP_NOEXCEPT - : layout::AccelerationStructureMemoryRequirementsInfoNV( type_, accelerationStructure_ ) + : type( type_ ) + , accelerationStructure( accelerationStructure_ ) {} + vk::AccelerationStructureMemoryRequirementsInfoNV & operator=( vk::AccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AccelerationStructureMemoryRequirementsInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AccelerationStructureMemoryRequirementsInfoNV( rhs ) - {} + { + *this = rhs; + } AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AccelerationStructureMemoryRequirementsInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -20084,69 +20191,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AccelerationStructureMemoryRequirementsInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV; + const void* pNext = nullptr; + vk::AccelerationStructureMemoryRequirementsTypeNV type; + vk::AccelerationStructureNV accelerationStructure; }; static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct AcquireNextImageInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(), - uint64_t timeout_ = 0, - vk::Semaphore semaphore_ = vk::Semaphore(), - vk::Fence fence_ = vk::Fence(), - uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT - : swapchain( swapchain_ ) - , timeout( timeout_ ) - , semaphore( semaphore_ ) - , fence( fence_ ) - , deviceMask( deviceMask_ ) - {} - - AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAcquireNextImageInfoKHR; - const void* pNext = nullptr; - vk::SwapchainKHR swapchain; - uint64_t timeout; - vk::Semaphore semaphore; - vk::Fence fence; - uint32_t deviceMask; - }; - static_assert( sizeof( AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct AcquireNextImageInfoKHR : public layout::AcquireNextImageInfoKHR + struct AcquireNextImageInfoKHR { VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(), uint64_t timeout_ = 0, vk::Semaphore semaphore_ = vk::Semaphore(), vk::Fence fence_ = vk::Fence(), uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::AcquireNextImageInfoKHR( swapchain_, timeout_, semaphore_, fence_, deviceMask_ ) + : swapchain( swapchain_ ) + , timeout( timeout_ ) + , semaphore( semaphore_ ) + , fence( fence_ ) + , deviceMask( deviceMask_ ) {} + vk::AcquireNextImageInfoKHR & operator=( vk::AcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AcquireNextImageInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AcquireNextImageInfoKHR( rhs ) - {} + { + *this = rhs; + } AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AcquireNextImageInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -20212,12 +20293,93 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AcquireNextImageInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eAcquireNextImageInfoKHR; + const void* pNext = nullptr; + vk::SwapchainKHR swapchain; + uint64_t timeout; + vk::Semaphore semaphore; + vk::Fence fence; + uint32_t deviceMask; }; static_assert( sizeof( AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + struct AcquireProfilingLockInfoKHR + { + VULKAN_HPP_CONSTEXPR AcquireProfilingLockInfoKHR( vk::AcquireProfilingLockFlagsKHR flags_ = vk::AcquireProfilingLockFlagsKHR(), + uint64_t timeout_ = 0 ) VULKAN_HPP_NOEXCEPT + : flags( flags_ ) + , timeout( timeout_ ) + {} + + vk::AcquireProfilingLockInfoKHR & operator=( vk::AcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AcquireProfilingLockInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + + AcquireProfilingLockInfoKHR( VkAcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } + + AcquireProfilingLockInfoKHR& operator=( VkAcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast(&rhs); + return *this; + } + + AcquireProfilingLockInfoKHR & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + AcquireProfilingLockInfoKHR & setFlags( vk::AcquireProfilingLockFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + AcquireProfilingLockInfoKHR & setTimeout( uint64_t timeout_ ) VULKAN_HPP_NOEXCEPT + { + timeout = timeout_; + return *this; + } + + operator VkAcquireProfilingLockInfoKHR const&() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAcquireProfilingLockInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( AcquireProfilingLockInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( timeout == rhs.timeout ); + } + + bool operator!=( AcquireProfilingLockInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + const vk::StructureType sType = StructureType::eAcquireProfilingLockInfoKHR; + const void* pNext = nullptr; + vk::AcquireProfilingLockFlagsKHR flags; + uint64_t timeout; + }; + static_assert( sizeof( AcquireProfilingLockInfoKHR ) == sizeof( VkAcquireProfilingLockInfoKHR ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + struct AllocationCallbacks { VULKAN_HPP_CONSTEXPR AllocationCallbacks( void* pUserData_ = nullptr, @@ -20236,12 +20398,12 @@ namespace VULKAN_HPP_NAMESPACE AllocationCallbacks( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -20331,12 +20493,12 @@ namespace VULKAN_HPP_NAMESPACE ComponentMapping( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ComponentMapping& operator=( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -20398,53 +20560,40 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_ANDROID_KHR - namespace layout + struct AndroidHardwareBufferFormatPropertiesANDROID { - struct AndroidHardwareBufferFormatPropertiesANDROID - { - protected: - AndroidHardwareBufferFormatPropertiesANDROID() VULKAN_HPP_NOEXCEPT - {} - - AndroidHardwareBufferFormatPropertiesANDROID( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AndroidHardwareBufferFormatPropertiesANDROID& operator=( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID; - void* pNext = nullptr; - vk::Format format; - uint64_t externalFormat; - vk::FormatFeatureFlags formatFeatures; - vk::ComponentMapping samplerYcbcrConversionComponents; - vk::SamplerYcbcrModelConversion suggestedYcbcrModel; - vk::SamplerYcbcrRange suggestedYcbcrRange; - vk::ChromaLocation suggestedXChromaOffset; - vk::ChromaLocation suggestedYChromaOffset; - }; - static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "layout struct and wrapper have different size!" ); - } - - struct AndroidHardwareBufferFormatPropertiesANDROID : public layout::AndroidHardwareBufferFormatPropertiesANDROID - { - AndroidHardwareBufferFormatPropertiesANDROID() VULKAN_HPP_NOEXCEPT - : layout::AndroidHardwareBufferFormatPropertiesANDROID() + AndroidHardwareBufferFormatPropertiesANDROID( vk::Format format_ = vk::Format::eUndefined, + uint64_t externalFormat_ = 0, + vk::FormatFeatureFlags formatFeatures_ = vk::FormatFeatureFlags(), + vk::ComponentMapping samplerYcbcrConversionComponents_ = vk::ComponentMapping(), + vk::SamplerYcbcrModelConversion suggestedYcbcrModel_ = vk::SamplerYcbcrModelConversion::eRgbIdentity, + vk::SamplerYcbcrRange suggestedYcbcrRange_ = vk::SamplerYcbcrRange::eItuFull, + vk::ChromaLocation suggestedXChromaOffset_ = vk::ChromaLocation::eCositedEven, + vk::ChromaLocation suggestedYChromaOffset_ = vk::ChromaLocation::eCositedEven ) VULKAN_HPP_NOEXCEPT + : format( format_ ) + , externalFormat( externalFormat_ ) + , formatFeatures( formatFeatures_ ) + , samplerYcbcrConversionComponents( samplerYcbcrConversionComponents_ ) + , suggestedYcbcrModel( suggestedYcbcrModel_ ) + , suggestedYcbcrRange( suggestedYcbcrRange_ ) + , suggestedXChromaOffset( suggestedXChromaOffset_ ) + , suggestedYChromaOffset( suggestedYChromaOffset_ ) {} + vk::AndroidHardwareBufferFormatPropertiesANDROID & operator=( vk::AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AndroidHardwareBufferFormatPropertiesANDROID ) - sizeof( vk::StructureType ) ); + return *this; + } + AndroidHardwareBufferFormatPropertiesANDROID( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AndroidHardwareBufferFormatPropertiesANDROID( rhs ) - {} + { + *this = rhs; + } AndroidHardwareBufferFormatPropertiesANDROID& operator=( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AndroidHardwareBufferFormatPropertiesANDROID::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -20477,8 +20626,17 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AndroidHardwareBufferFormatPropertiesANDROID::sType; + public: + const vk::StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID; + void* pNext = nullptr; + vk::Format format; + uint64_t externalFormat; + vk::FormatFeatureFlags formatFeatures; + vk::ComponentMapping samplerYcbcrConversionComponents; + vk::SamplerYcbcrModelConversion suggestedYcbcrModel; + vk::SamplerYcbcrRange suggestedYcbcrRange; + vk::ChromaLocation suggestedXChromaOffset; + vk::ChromaLocation suggestedYChromaOffset; }; static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -20486,47 +20644,28 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_ANDROID_KHR - namespace layout + struct AndroidHardwareBufferPropertiesANDROID { - struct AndroidHardwareBufferPropertiesANDROID - { - protected: - AndroidHardwareBufferPropertiesANDROID() VULKAN_HPP_NOEXCEPT - {} - - AndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AndroidHardwareBufferPropertiesANDROID& operator=( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID; - void* pNext = nullptr; - vk::DeviceSize allocationSize; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "layout struct and wrapper have different size!" ); - } - - struct AndroidHardwareBufferPropertiesANDROID : public layout::AndroidHardwareBufferPropertiesANDROID - { - AndroidHardwareBufferPropertiesANDROID() VULKAN_HPP_NOEXCEPT - : layout::AndroidHardwareBufferPropertiesANDROID() + AndroidHardwareBufferPropertiesANDROID( vk::DeviceSize allocationSize_ = 0, + uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT + : allocationSize( allocationSize_ ) + , memoryTypeBits( memoryTypeBits_ ) {} + vk::AndroidHardwareBufferPropertiesANDROID & operator=( vk::AndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AndroidHardwareBufferPropertiesANDROID ) - sizeof( vk::StructureType ) ); + return *this; + } + AndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AndroidHardwareBufferPropertiesANDROID( rhs ) - {} + { + *this = rhs; + } AndroidHardwareBufferPropertiesANDROID& operator=( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AndroidHardwareBufferPropertiesANDROID::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -20553,8 +20692,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AndroidHardwareBufferPropertiesANDROID::sType; + public: + const vk::StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID; + void* pNext = nullptr; + vk::DeviceSize allocationSize; + uint32_t memoryTypeBits; }; static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -20562,46 +20704,26 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_ANDROID_KHR - namespace layout + struct AndroidHardwareBufferUsageANDROID { - struct AndroidHardwareBufferUsageANDROID - { - protected: - AndroidHardwareBufferUsageANDROID() VULKAN_HPP_NOEXCEPT - {} - - AndroidHardwareBufferUsageANDROID( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AndroidHardwareBufferUsageANDROID& operator=( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID; - void* pNext = nullptr; - uint64_t androidHardwareBufferUsage; - }; - static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "layout struct and wrapper have different size!" ); - } - - struct AndroidHardwareBufferUsageANDROID : public layout::AndroidHardwareBufferUsageANDROID - { - AndroidHardwareBufferUsageANDROID() VULKAN_HPP_NOEXCEPT - : layout::AndroidHardwareBufferUsageANDROID() + AndroidHardwareBufferUsageANDROID( uint64_t androidHardwareBufferUsage_ = 0 ) VULKAN_HPP_NOEXCEPT + : androidHardwareBufferUsage( androidHardwareBufferUsage_ ) {} + vk::AndroidHardwareBufferUsageANDROID & operator=( vk::AndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AndroidHardwareBufferUsageANDROID ) - sizeof( vk::StructureType ) ); + return *this; + } + AndroidHardwareBufferUsageANDROID( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AndroidHardwareBufferUsageANDROID( rhs ) - {} + { + *this = rhs; + } AndroidHardwareBufferUsageANDROID& operator=( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AndroidHardwareBufferUsageANDROID::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -20627,8 +20749,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AndroidHardwareBufferUsageANDROID::sType; + public: + const vk::StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID; + void* pNext = nullptr; + uint64_t androidHardwareBufferUsage; }; static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -20636,51 +20760,28 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_ANDROID_KHR - namespace layout - { - struct AndroidSurfaceCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( vk::AndroidSurfaceCreateFlagsKHR flags_ = vk::AndroidSurfaceCreateFlagsKHR(), - struct ANativeWindow* window_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , window( window_ ) - {} - - AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR; - const void* pNext = nullptr; - vk::AndroidSurfaceCreateFlagsKHR flags; - struct ANativeWindow* window; - }; - static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct AndroidSurfaceCreateInfoKHR : public layout::AndroidSurfaceCreateInfoKHR + struct AndroidSurfaceCreateInfoKHR { VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( vk::AndroidSurfaceCreateFlagsKHR flags_ = vk::AndroidSurfaceCreateFlagsKHR(), struct ANativeWindow* window_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::AndroidSurfaceCreateInfoKHR( flags_, window_ ) + : flags( flags_ ) + , window( window_ ) {} + vk::AndroidSurfaceCreateInfoKHR & operator=( vk::AndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AndroidSurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AndroidSurfaceCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AndroidSurfaceCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -20725,70 +20826,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AndroidSurfaceCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR; + const void* pNext = nullptr; + vk::AndroidSurfaceCreateFlagsKHR flags; + struct ANativeWindow* window; }; static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - namespace layout - { - struct ApplicationInfo - { - protected: - VULKAN_HPP_CONSTEXPR ApplicationInfo( const char* pApplicationName_ = nullptr, - uint32_t applicationVersion_ = 0, - const char* pEngineName_ = nullptr, - uint32_t engineVersion_ = 0, - uint32_t apiVersion_ = 0 ) VULKAN_HPP_NOEXCEPT - : pApplicationName( pApplicationName_ ) - , applicationVersion( applicationVersion_ ) - , pEngineName( pEngineName_ ) - , engineVersion( engineVersion_ ) - , apiVersion( apiVersion_ ) - {} - - ApplicationInfo( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ApplicationInfo& operator=( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eApplicationInfo; - const void* pNext = nullptr; - const char* pApplicationName; - uint32_t applicationVersion; - const char* pEngineName; - uint32_t engineVersion; - uint32_t apiVersion; - }; - static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "layout struct and wrapper have different size!" ); - } - - struct ApplicationInfo : public layout::ApplicationInfo + struct ApplicationInfo { VULKAN_HPP_CONSTEXPR ApplicationInfo( const char* pApplicationName_ = nullptr, uint32_t applicationVersion_ = 0, const char* pEngineName_ = nullptr, uint32_t engineVersion_ = 0, uint32_t apiVersion_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ApplicationInfo( pApplicationName_, applicationVersion_, pEngineName_, engineVersion_, apiVersion_ ) + : pApplicationName( pApplicationName_ ) + , applicationVersion( applicationVersion_ ) + , pEngineName( pEngineName_ ) + , engineVersion( engineVersion_ ) + , apiVersion( apiVersion_ ) {} + vk::ApplicationInfo & operator=( vk::ApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ApplicationInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ApplicationInfo( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ApplicationInfo( rhs ) - {} + { + *this = rhs; + } ApplicationInfo& operator=( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ApplicationInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -20854,8 +20929,14 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ApplicationInfo::sType; + public: + const vk::StructureType sType = StructureType::eApplicationInfo; + const void* pNext = nullptr; + const char* pApplicationName; + uint32_t applicationVersion; + 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::value, "struct wrapper is not a standard layout!" ); @@ -20884,12 +20965,12 @@ namespace VULKAN_HPP_NAMESPACE AttachmentDescription( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } AttachmentDescription& operator=( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -20989,59 +21070,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct AttachmentDescription2KHR - { - protected: - VULKAN_HPP_CONSTEXPR AttachmentDescription2KHR( vk::AttachmentDescriptionFlags flags_ = vk::AttachmentDescriptionFlags(), - vk::Format format_ = vk::Format::eUndefined, - vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1, - vk::AttachmentLoadOp loadOp_ = vk::AttachmentLoadOp::eLoad, - vk::AttachmentStoreOp storeOp_ = vk::AttachmentStoreOp::eStore, - vk::AttachmentLoadOp stencilLoadOp_ = vk::AttachmentLoadOp::eLoad, - vk::AttachmentStoreOp stencilStoreOp_ = vk::AttachmentStoreOp::eStore, - vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined, - vk::ImageLayout finalLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , format( format_ ) - , samples( samples_ ) - , loadOp( loadOp_ ) - , storeOp( storeOp_ ) - , stencilLoadOp( stencilLoadOp_ ) - , stencilStoreOp( stencilStoreOp_ ) - , initialLayout( initialLayout_ ) - , finalLayout( finalLayout_ ) - {} - - AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAttachmentDescription2KHR; - const void* pNext = nullptr; - vk::AttachmentDescriptionFlags flags; - vk::Format format; - vk::SampleCountFlagBits samples; - vk::AttachmentLoadOp loadOp; - vk::AttachmentStoreOp storeOp; - vk::AttachmentLoadOp stencilLoadOp; - vk::AttachmentStoreOp stencilStoreOp; - vk::ImageLayout initialLayout; - vk::ImageLayout finalLayout; - }; - static_assert( sizeof( AttachmentDescription2KHR ) == sizeof( VkAttachmentDescription2KHR ), "layout struct and wrapper have different size!" ); - } - - struct AttachmentDescription2KHR : public layout::AttachmentDescription2KHR + struct AttachmentDescription2KHR { VULKAN_HPP_CONSTEXPR AttachmentDescription2KHR( vk::AttachmentDescriptionFlags flags_ = vk::AttachmentDescriptionFlags(), vk::Format format_ = vk::Format::eUndefined, @@ -21052,16 +21081,31 @@ namespace VULKAN_HPP_NAMESPACE vk::AttachmentStoreOp stencilStoreOp_ = vk::AttachmentStoreOp::eStore, vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined, vk::ImageLayout finalLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : layout::AttachmentDescription2KHR( flags_, format_, samples_, loadOp_, storeOp_, stencilLoadOp_, stencilStoreOp_, initialLayout_, finalLayout_ ) + : flags( flags_ ) + , format( format_ ) + , samples( samples_ ) + , loadOp( loadOp_ ) + , storeOp( storeOp_ ) + , stencilLoadOp( stencilLoadOp_ ) + , stencilStoreOp( stencilStoreOp_ ) + , initialLayout( initialLayout_ ) + , finalLayout( finalLayout_ ) {} + vk::AttachmentDescription2KHR & operator=( vk::AttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AttachmentDescription2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + AttachmentDescription2KHR( VkAttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AttachmentDescription2KHR( rhs ) - {} + { + *this = rhs; + } AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AttachmentDescription2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -21155,57 +21199,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AttachmentDescription2KHR::sType; + public: + const vk::StructureType sType = StructureType::eAttachmentDescription2KHR; + const void* pNext = nullptr; + vk::AttachmentDescriptionFlags flags; + vk::Format format; + vk::SampleCountFlagBits samples; + vk::AttachmentLoadOp loadOp; + vk::AttachmentStoreOp storeOp; + vk::AttachmentLoadOp stencilLoadOp; + vk::AttachmentStoreOp stencilStoreOp; + vk::ImageLayout initialLayout; + vk::ImageLayout finalLayout; }; static_assert( sizeof( AttachmentDescription2KHR ) == sizeof( VkAttachmentDescription2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct AttachmentDescriptionStencilLayoutKHR - { - protected: - VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayoutKHR( vk::ImageLayout stencilInitialLayout_ = vk::ImageLayout::eUndefined, - vk::ImageLayout stencilFinalLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : stencilInitialLayout( stencilInitialLayout_ ) - , stencilFinalLayout( stencilFinalLayout_ ) - {} - - AttachmentDescriptionStencilLayoutKHR( VkAttachmentDescriptionStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AttachmentDescriptionStencilLayoutKHR& operator=( VkAttachmentDescriptionStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAttachmentDescriptionStencilLayoutKHR; - void* pNext = nullptr; - vk::ImageLayout stencilInitialLayout; - vk::ImageLayout stencilFinalLayout; - }; - static_assert( sizeof( AttachmentDescriptionStencilLayoutKHR ) == sizeof( VkAttachmentDescriptionStencilLayoutKHR ), "layout struct and wrapper have different size!" ); - } - - struct AttachmentDescriptionStencilLayoutKHR : public layout::AttachmentDescriptionStencilLayoutKHR + struct AttachmentDescriptionStencilLayoutKHR { VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayoutKHR( vk::ImageLayout stencilInitialLayout_ = vk::ImageLayout::eUndefined, vk::ImageLayout stencilFinalLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : layout::AttachmentDescriptionStencilLayoutKHR( stencilInitialLayout_, stencilFinalLayout_ ) + : stencilInitialLayout( stencilInitialLayout_ ) + , stencilFinalLayout( stencilFinalLayout_ ) {} + vk::AttachmentDescriptionStencilLayoutKHR & operator=( vk::AttachmentDescriptionStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AttachmentDescriptionStencilLayoutKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + AttachmentDescriptionStencilLayoutKHR( VkAttachmentDescriptionStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AttachmentDescriptionStencilLayoutKHR( rhs ) - {} + { + *this = rhs; + } AttachmentDescriptionStencilLayoutKHR& operator=( VkAttachmentDescriptionStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AttachmentDescriptionStencilLayoutKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -21250,8 +21281,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AttachmentDescriptionStencilLayoutKHR::sType; + public: + const vk::StructureType sType = StructureType::eAttachmentDescriptionStencilLayoutKHR; + void* pNext = nullptr; + vk::ImageLayout stencilInitialLayout; + vk::ImageLayout stencilFinalLayout; }; static_assert( sizeof( AttachmentDescriptionStencilLayoutKHR ) == sizeof( VkAttachmentDescriptionStencilLayoutKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -21266,12 +21300,12 @@ namespace VULKAN_HPP_NAMESPACE AttachmentReference( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } AttachmentReference& operator=( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -21315,55 +21349,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct AttachmentReference2KHR - { - protected: - VULKAN_HPP_CONSTEXPR AttachmentReference2KHR( uint32_t attachment_ = 0, - vk::ImageLayout layout_ = vk::ImageLayout::eUndefined, - vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags() ) VULKAN_HPP_NOEXCEPT - : attachment( attachment_ ) - , layout( layout_ ) - , aspectMask( aspectMask_ ) - {} - - AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAttachmentReference2KHR; - const void* pNext = nullptr; - uint32_t attachment; - vk::ImageLayout layout; - vk::ImageAspectFlags aspectMask; - }; - static_assert( sizeof( AttachmentReference2KHR ) == sizeof( VkAttachmentReference2KHR ), "layout struct and wrapper have different size!" ); - } - - struct AttachmentReference2KHR : public layout::AttachmentReference2KHR + struct AttachmentReference2KHR { VULKAN_HPP_CONSTEXPR AttachmentReference2KHR( uint32_t attachment_ = 0, vk::ImageLayout layout_ = vk::ImageLayout::eUndefined, vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags() ) VULKAN_HPP_NOEXCEPT - : layout::AttachmentReference2KHR( attachment_, layout_, aspectMask_ ) + : attachment( attachment_ ) + , layout( layout_ ) + , aspectMask( aspectMask_ ) {} + vk::AttachmentReference2KHR & operator=( vk::AttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AttachmentReference2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + AttachmentReference2KHR( VkAttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AttachmentReference2KHR( rhs ) - {} + { + *this = rhs; + } AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AttachmentReference2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -21415,53 +21424,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AttachmentReference2KHR::sType; + public: + const vk::StructureType sType = StructureType::eAttachmentReference2KHR; + const void* pNext = nullptr; + uint32_t attachment; + vk::ImageLayout layout; + vk::ImageAspectFlags aspectMask; }; static_assert( sizeof( AttachmentReference2KHR ) == sizeof( VkAttachmentReference2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct AttachmentReferenceStencilLayoutKHR - { - protected: - VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayoutKHR( vk::ImageLayout stencilLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : stencilLayout( stencilLayout_ ) - {} - - AttachmentReferenceStencilLayoutKHR( VkAttachmentReferenceStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - AttachmentReferenceStencilLayoutKHR& operator=( VkAttachmentReferenceStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eAttachmentReferenceStencilLayoutKHR; - void* pNext = nullptr; - vk::ImageLayout stencilLayout; - }; - static_assert( sizeof( AttachmentReferenceStencilLayoutKHR ) == sizeof( VkAttachmentReferenceStencilLayoutKHR ), "layout struct and wrapper have different size!" ); - } - - struct AttachmentReferenceStencilLayoutKHR : public layout::AttachmentReferenceStencilLayoutKHR + struct AttachmentReferenceStencilLayoutKHR { VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayoutKHR( vk::ImageLayout stencilLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : layout::AttachmentReferenceStencilLayoutKHR( stencilLayout_ ) + : stencilLayout( stencilLayout_ ) {} + vk::AttachmentReferenceStencilLayoutKHR & operator=( vk::AttachmentReferenceStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::AttachmentReferenceStencilLayoutKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + AttachmentReferenceStencilLayoutKHR( VkAttachmentReferenceStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::AttachmentReferenceStencilLayoutKHR( rhs ) - {} + { + *this = rhs; + } AttachmentReferenceStencilLayoutKHR& operator=( VkAttachmentReferenceStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::AttachmentReferenceStencilLayoutKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -21499,8 +21491,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::AttachmentReferenceStencilLayoutKHR::sType; + public: + const vk::StructureType sType = StructureType::eAttachmentReferenceStencilLayoutKHR; + void* pNext = nullptr; + vk::ImageLayout stencilLayout; }; static_assert( sizeof( AttachmentReferenceStencilLayoutKHR ) == sizeof( VkAttachmentReferenceStencilLayoutKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -21515,12 +21509,12 @@ namespace VULKAN_HPP_NAMESPACE Extent2D( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } Extent2D& operator=( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -21574,12 +21568,12 @@ namespace VULKAN_HPP_NAMESPACE SampleLocationEXT( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SampleLocationEXT& operator=( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -21623,59 +21617,32 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SampleLocationsInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( vk::SampleCountFlagBits sampleLocationsPerPixel_ = vk::SampleCountFlagBits::e1, - vk::Extent2D sampleLocationGridSize_ = vk::Extent2D(), - uint32_t sampleLocationsCount_ = 0, - const vk::SampleLocationEXT* pSampleLocations_ = nullptr ) VULKAN_HPP_NOEXCEPT - : sampleLocationsPerPixel( sampleLocationsPerPixel_ ) - , sampleLocationGridSize( sampleLocationGridSize_ ) - , sampleLocationsCount( sampleLocationsCount_ ) - , pSampleLocations( pSampleLocations_ ) - {} - - SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSampleLocationsInfoEXT; - const void* pNext = nullptr; - vk::SampleCountFlagBits sampleLocationsPerPixel; - vk::Extent2D sampleLocationGridSize; - uint32_t sampleLocationsCount; - const vk::SampleLocationEXT* pSampleLocations; - }; - static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct SampleLocationsInfoEXT : public layout::SampleLocationsInfoEXT + struct SampleLocationsInfoEXT { VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( vk::SampleCountFlagBits sampleLocationsPerPixel_ = vk::SampleCountFlagBits::e1, vk::Extent2D sampleLocationGridSize_ = vk::Extent2D(), uint32_t sampleLocationsCount_ = 0, const vk::SampleLocationEXT* pSampleLocations_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::SampleLocationsInfoEXT( sampleLocationsPerPixel_, sampleLocationGridSize_, sampleLocationsCount_, pSampleLocations_ ) + : sampleLocationsPerPixel( sampleLocationsPerPixel_ ) + , sampleLocationGridSize( sampleLocationGridSize_ ) + , sampleLocationsCount( sampleLocationsCount_ ) + , pSampleLocations( pSampleLocations_ ) {} + vk::SampleLocationsInfoEXT & operator=( vk::SampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SampleLocationsInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SampleLocationsInfoEXT( rhs ) - {} + { + *this = rhs; + } SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SampleLocationsInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -21734,8 +21701,13 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SampleLocationsInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eSampleLocationsInfoEXT; + const void* pNext = nullptr; + vk::SampleCountFlagBits sampleLocationsPerPixel; + vk::Extent2D sampleLocationGridSize; + uint32_t sampleLocationsCount; + const vk::SampleLocationEXT* pSampleLocations; }; static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -21750,12 +21722,12 @@ namespace VULKAN_HPP_NAMESPACE AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } AttachmentSampleLocationsEXT& operator=( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -21799,45 +21771,19 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BaseInStructure - { - protected: - BaseInStructure() VULKAN_HPP_NOEXCEPT - {} - - BaseInStructure( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BaseInStructure& operator=( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType; - const struct vk::BaseInStructure* pNext = nullptr; - }; - static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "layout struct and wrapper have different size!" ); - } - - struct BaseInStructure : public layout::BaseInStructure + struct BaseInStructure { BaseInStructure() VULKAN_HPP_NOEXCEPT - : layout::BaseInStructure() {} BaseInStructure( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BaseInStructure( rhs ) - {} + { + *this = rhs; + } BaseInStructure& operator=( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BaseInStructure::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -21868,51 +21814,26 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BaseInStructure::sType; + public: + vk::StructureType sType; + const struct vk::BaseInStructure* pNext = nullptr; }; static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BaseOutStructure - { - protected: - BaseOutStructure() VULKAN_HPP_NOEXCEPT - {} - - BaseOutStructure( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BaseOutStructure& operator=( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType; - struct vk::BaseOutStructure* pNext = nullptr; - }; - static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "layout struct and wrapper have different size!" ); - } - - struct BaseOutStructure : public layout::BaseOutStructure + struct BaseOutStructure { BaseOutStructure() VULKAN_HPP_NOEXCEPT - : layout::BaseOutStructure() {} BaseOutStructure( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BaseOutStructure( rhs ) - {} + { + *this = rhs; + } BaseOutStructure& operator=( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BaseOutStructure::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -21943,69 +21864,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BaseOutStructure::sType; + public: + vk::StructureType sType; + struct vk::BaseOutStructure* pNext = nullptr; }; static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindAccelerationStructureMemoryInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoNV( vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV(), - vk::DeviceMemory memory_ = vk::DeviceMemory(), - vk::DeviceSize memoryOffset_ = 0, - uint32_t deviceIndexCount_ = 0, - const uint32_t* pDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : accelerationStructure( accelerationStructure_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - , deviceIndexCount( deviceIndexCount_ ) - , pDeviceIndices( pDeviceIndices_ ) - {} - - BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV; - const void* pNext = nullptr; - vk::AccelerationStructureNV accelerationStructure; - vk::DeviceMemory memory; - vk::DeviceSize memoryOffset; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; - }; - static_assert( sizeof( BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct BindAccelerationStructureMemoryInfoNV : public layout::BindAccelerationStructureMemoryInfoNV + struct BindAccelerationStructureMemoryInfoNV { VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoNV( vk::AccelerationStructureNV accelerationStructure_ = vk::AccelerationStructureNV(), vk::DeviceMemory memory_ = vk::DeviceMemory(), vk::DeviceSize memoryOffset_ = 0, uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::BindAccelerationStructureMemoryInfoNV( accelerationStructure_, memory_, memoryOffset_, deviceIndexCount_, pDeviceIndices_ ) + : accelerationStructure( accelerationStructure_ ) + , memory( memory_ ) + , memoryOffset( memoryOffset_ ) + , deviceIndexCount( deviceIndexCount_ ) + , pDeviceIndices( pDeviceIndices_ ) {} + vk::BindAccelerationStructureMemoryInfoNV & operator=( vk::BindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindAccelerationStructureMemoryInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindAccelerationStructureMemoryInfoNV( rhs ) - {} + { + *this = rhs; + } BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindAccelerationStructureMemoryInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -22071,57 +21964,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindAccelerationStructureMemoryInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV; + const void* pNext = nullptr; + vk::AccelerationStructureNV accelerationStructure; + vk::DeviceMemory memory; + vk::DeviceSize memoryOffset; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; }; static_assert( sizeof( BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindBufferMemoryDeviceGroupInfo - { - protected: - VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0, - const uint32_t* pDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : deviceIndexCount( deviceIndexCount_ ) - , pDeviceIndices( pDeviceIndices_ ) - {} - - BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo; - const void* pNext = nullptr; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; - }; - static_assert( sizeof( BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), "layout struct and wrapper have different size!" ); - } - - struct BindBufferMemoryDeviceGroupInfo : public layout::BindBufferMemoryDeviceGroupInfo + struct BindBufferMemoryDeviceGroupInfo { VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::BindBufferMemoryDeviceGroupInfo( deviceIndexCount_, pDeviceIndices_ ) + : deviceIndexCount( deviceIndexCount_ ) + , pDeviceIndices( pDeviceIndices_ ) {} + vk::BindBufferMemoryDeviceGroupInfo & operator=( vk::BindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindBufferMemoryDeviceGroupInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindBufferMemoryDeviceGroupInfo( rhs ) - {} + { + *this = rhs; + } BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindBufferMemoryDeviceGroupInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -22166,61 +22042,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindBufferMemoryDeviceGroupInfo::sType; + public: + const vk::StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo; + const void* pNext = nullptr; + 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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindBufferMemoryInfo - { - protected: - VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( vk::Buffer buffer_ = vk::Buffer(), - vk::DeviceMemory memory_ = vk::DeviceMemory(), - vk::DeviceSize memoryOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : buffer( buffer_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - {} - - BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindBufferMemoryInfo; - const void* pNext = nullptr; - vk::Buffer buffer; - vk::DeviceMemory memory; - vk::DeviceSize memoryOffset; - }; - static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "layout struct and wrapper have different size!" ); - } - - struct BindBufferMemoryInfo : public layout::BindBufferMemoryInfo + struct BindBufferMemoryInfo { VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( vk::Buffer buffer_ = vk::Buffer(), vk::DeviceMemory memory_ = vk::DeviceMemory(), vk::DeviceSize memoryOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::BindBufferMemoryInfo( buffer_, memory_, memoryOffset_ ) + : buffer( buffer_ ) + , memory( memory_ ) + , memoryOffset( memoryOffset_ ) {} + vk::BindBufferMemoryInfo & operator=( vk::BindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindBufferMemoryInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindBufferMemoryInfo( rhs ) - {} + { + *this = rhs; + } BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindBufferMemoryInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -22272,8 +22126,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindBufferMemoryInfo::sType; + public: + const vk::StructureType sType = StructureType::eBindBufferMemoryInfo; + const void* pNext = nullptr; + vk::Buffer buffer; + vk::DeviceMemory memory; + vk::DeviceSize memoryOffset; }; static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -22288,12 +22146,12 @@ namespace VULKAN_HPP_NAMESPACE Offset2D( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } Offset2D& operator=( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -22347,12 +22205,12 @@ namespace VULKAN_HPP_NAMESPACE Rect2D( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } Rect2D& operator=( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -22396,59 +22254,32 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindImageMemoryDeviceGroupInfo - { - protected: - VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0, - const uint32_t* pDeviceIndices_ = nullptr, - uint32_t splitInstanceBindRegionCount_ = 0, - const vk::Rect2D* pSplitInstanceBindRegions_ = nullptr ) VULKAN_HPP_NOEXCEPT - : deviceIndexCount( deviceIndexCount_ ) - , pDeviceIndices( pDeviceIndices_ ) - , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ ) - , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ ) - {} - - BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo; - const void* pNext = nullptr; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; - uint32_t splitInstanceBindRegionCount; - const vk::Rect2D* pSplitInstanceBindRegions; - }; - static_assert( sizeof( BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), "layout struct and wrapper have different size!" ); - } - - struct BindImageMemoryDeviceGroupInfo : public layout::BindImageMemoryDeviceGroupInfo + struct BindImageMemoryDeviceGroupInfo { VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr, uint32_t splitInstanceBindRegionCount_ = 0, const vk::Rect2D* pSplitInstanceBindRegions_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::BindImageMemoryDeviceGroupInfo( deviceIndexCount_, pDeviceIndices_, splitInstanceBindRegionCount_, pSplitInstanceBindRegions_ ) + : deviceIndexCount( deviceIndexCount_ ) + , pDeviceIndices( pDeviceIndices_ ) + , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ ) + , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ ) {} + vk::BindImageMemoryDeviceGroupInfo & operator=( vk::BindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindImageMemoryDeviceGroupInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindImageMemoryDeviceGroupInfo( rhs ) - {} + { + *this = rhs; + } BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindImageMemoryDeviceGroupInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -22507,61 +22338,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindImageMemoryDeviceGroupInfo::sType; + public: + const vk::StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo; + const void* pNext = nullptr; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; + uint32_t splitInstanceBindRegionCount; + const vk::Rect2D* pSplitInstanceBindRegions; }; static_assert( sizeof( BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindImageMemoryInfo - { - protected: - VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( vk::Image image_ = vk::Image(), - vk::DeviceMemory memory_ = vk::DeviceMemory(), - vk::DeviceSize memoryOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : image( image_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - {} - - BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindImageMemoryInfo; - const void* pNext = nullptr; - vk::Image image; - vk::DeviceMemory memory; - vk::DeviceSize memoryOffset; - }; - static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "layout struct and wrapper have different size!" ); - } - - struct BindImageMemoryInfo : public layout::BindImageMemoryInfo + struct BindImageMemoryInfo { VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( vk::Image image_ = vk::Image(), vk::DeviceMemory memory_ = vk::DeviceMemory(), vk::DeviceSize memoryOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::BindImageMemoryInfo( image_, memory_, memoryOffset_ ) + : image( image_ ) + , memory( memory_ ) + , memoryOffset( memoryOffset_ ) {} + vk::BindImageMemoryInfo & operator=( vk::BindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindImageMemoryInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindImageMemoryInfo( rhs ) - {} + { + *this = rhs; + } BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindImageMemoryInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -22613,57 +22424,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindImageMemoryInfo::sType; + public: + const vk::StructureType sType = StructureType::eBindImageMemoryInfo; + const void* pNext = nullptr; + vk::Image image; + vk::DeviceMemory memory; + vk::DeviceSize memoryOffset; }; static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindImageMemorySwapchainInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(), - uint32_t imageIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : swapchain( swapchain_ ) - , imageIndex( imageIndex_ ) - {} - - BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR; - const void* pNext = nullptr; - vk::SwapchainKHR swapchain; - uint32_t imageIndex; - }; - static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct BindImageMemorySwapchainInfoKHR : public layout::BindImageMemorySwapchainInfoKHR + struct BindImageMemorySwapchainInfoKHR { VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR(), uint32_t imageIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::BindImageMemorySwapchainInfoKHR( swapchain_, imageIndex_ ) + : swapchain( swapchain_ ) + , imageIndex( imageIndex_ ) {} + vk::BindImageMemorySwapchainInfoKHR & operator=( vk::BindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindImageMemorySwapchainInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindImageMemorySwapchainInfoKHR( rhs ) - {} + { + *this = rhs; + } BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindImageMemorySwapchainInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -22708,53 +22500,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindImageMemorySwapchainInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR; + const void* pNext = nullptr; + vk::SwapchainKHR swapchain; + uint32_t imageIndex; }; static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindImagePlaneMemoryInfo - { - protected: - VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT - : planeAspect( planeAspect_ ) - {} - - BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindImagePlaneMemoryInfo; - const void* pNext = nullptr; - vk::ImageAspectFlagBits planeAspect; - }; - static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "layout struct and wrapper have different size!" ); - } - - struct BindImagePlaneMemoryInfo : public layout::BindImagePlaneMemoryInfo + struct BindImagePlaneMemoryInfo { VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT - : layout::BindImagePlaneMemoryInfo( planeAspect_ ) + : planeAspect( planeAspect_ ) {} + vk::BindImagePlaneMemoryInfo & operator=( vk::BindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindImagePlaneMemoryInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindImagePlaneMemoryInfo( rhs ) - {} + { + *this = rhs; + } BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindImagePlaneMemoryInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -22792,8 +22566,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindImagePlaneMemoryInfo::sType; + public: + const vk::StructureType sType = StructureType::eBindImagePlaneMemoryInfo; + const void* pNext = nullptr; + vk::ImageAspectFlagBits planeAspect; }; static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -22814,12 +22590,12 @@ namespace VULKAN_HPP_NAMESPACE SparseMemoryBind( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -22899,12 +22675,12 @@ namespace VULKAN_HPP_NAMESPACE SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -22968,12 +22744,12 @@ namespace VULKAN_HPP_NAMESPACE SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -23037,12 +22813,12 @@ namespace VULKAN_HPP_NAMESPACE ImageSubresource( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ImageSubresource& operator=( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -23113,12 +22889,12 @@ namespace VULKAN_HPP_NAMESPACE Offset3D( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } Offset3D& operator=( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -23189,12 +22965,12 @@ namespace VULKAN_HPP_NAMESPACE Extent3D( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } Extent3D& operator=( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -23264,12 +23040,12 @@ namespace VULKAN_HPP_NAMESPACE SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -23357,12 +23133,12 @@ namespace VULKAN_HPP_NAMESPACE SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -23414,62 +23190,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BindSparseInfo - { - protected: - VULKAN_HPP_CONSTEXPR BindSparseInfo( uint32_t waitSemaphoreCount_ = 0, - const vk::Semaphore* pWaitSemaphores_ = nullptr, - uint32_t bufferBindCount_ = 0, - const vk::SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr, - uint32_t imageOpaqueBindCount_ = 0, - const vk::SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr, - uint32_t imageBindCount_ = 0, - const vk::SparseImageMemoryBindInfo* pImageBinds_ = nullptr, - uint32_t signalSemaphoreCount_ = 0, - const vk::Semaphore* pSignalSemaphores_ = nullptr ) VULKAN_HPP_NOEXCEPT - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphores( pWaitSemaphores_ ) - , bufferBindCount( bufferBindCount_ ) - , pBufferBinds( pBufferBinds_ ) - , imageOpaqueBindCount( imageOpaqueBindCount_ ) - , pImageOpaqueBinds( pImageOpaqueBinds_ ) - , imageBindCount( imageBindCount_ ) - , pImageBinds( pImageBinds_ ) - , signalSemaphoreCount( signalSemaphoreCount_ ) - , pSignalSemaphores( pSignalSemaphores_ ) - {} - - BindSparseInfo( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BindSparseInfo& operator=( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBindSparseInfo; - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const vk::Semaphore* pWaitSemaphores; - uint32_t bufferBindCount; - const vk::SparseBufferMemoryBindInfo* pBufferBinds; - uint32_t imageOpaqueBindCount; - const vk::SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; - uint32_t imageBindCount; - const vk::SparseImageMemoryBindInfo* pImageBinds; - uint32_t signalSemaphoreCount; - const vk::Semaphore* pSignalSemaphores; - }; - static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "layout struct and wrapper have different size!" ); - } - - struct BindSparseInfo : public layout::BindSparseInfo + struct BindSparseInfo { VULKAN_HPP_CONSTEXPR BindSparseInfo( uint32_t waitSemaphoreCount_ = 0, const vk::Semaphore* pWaitSemaphores_ = nullptr, @@ -23481,16 +23202,32 @@ namespace VULKAN_HPP_NAMESPACE const vk::SparseImageMemoryBindInfo* pImageBinds_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const vk::Semaphore* pSignalSemaphores_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::BindSparseInfo( waitSemaphoreCount_, pWaitSemaphores_, bufferBindCount_, pBufferBinds_, imageOpaqueBindCount_, pImageOpaqueBinds_, imageBindCount_, pImageBinds_, signalSemaphoreCount_, pSignalSemaphores_ ) + : waitSemaphoreCount( waitSemaphoreCount_ ) + , pWaitSemaphores( pWaitSemaphores_ ) + , bufferBindCount( bufferBindCount_ ) + , pBufferBinds( pBufferBinds_ ) + , imageOpaqueBindCount( imageOpaqueBindCount_ ) + , pImageOpaqueBinds( pImageOpaqueBinds_ ) + , imageBindCount( imageBindCount_ ) + , pImageBinds( pImageBinds_ ) + , signalSemaphoreCount( signalSemaphoreCount_ ) + , pSignalSemaphores( pSignalSemaphores_ ) {} + vk::BindSparseInfo & operator=( vk::BindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BindSparseInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BindSparseInfo( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BindSparseInfo( rhs ) - {} + { + *this = rhs; + } BindSparseInfo& operator=( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BindSparseInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -23591,8 +23328,19 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BindSparseInfo::sType; + public: + const vk::StructureType sType = StructureType::eBindSparseInfo; + const void* pNext = nullptr; + uint32_t waitSemaphoreCount; + const vk::Semaphore* pWaitSemaphores; + uint32_t bufferBindCount; + const vk::SparseBufferMemoryBindInfo* pBufferBinds; + uint32_t imageOpaqueBindCount; + const vk::SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; + uint32_t imageBindCount; + const vk::SparseImageMemoryBindInfo* pImageBinds; + uint32_t signalSemaphoreCount; + const vk::Semaphore* pSignalSemaphores; }; static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -23609,12 +23357,12 @@ namespace VULKAN_HPP_NAMESPACE BufferCopy( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } BufferCopy& operator=( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -23666,50 +23414,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BufferCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR BufferCreateInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(), - vk::DeviceSize size_ = 0, - vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(), - vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = 0, - const uint32_t* pQueueFamilyIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , size( size_ ) - , usage( usage_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - {} - - BufferCreateInfo( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBufferCreateInfo; - const void* pNext = nullptr; - vk::BufferCreateFlags flags; - vk::DeviceSize size; - vk::BufferUsageFlags usage; - vk::SharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - }; - static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct BufferCreateInfo : public layout::BufferCreateInfo + struct BufferCreateInfo { VULKAN_HPP_CONSTEXPR BufferCreateInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(), vk::DeviceSize size_ = 0, @@ -23717,16 +23422,28 @@ namespace VULKAN_HPP_NAMESPACE vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::BufferCreateInfo( flags_, size_, usage_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_ ) + : flags( flags_ ) + , size( size_ ) + , usage( usage_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( queueFamilyIndexCount_ ) + , pQueueFamilyIndices( pQueueFamilyIndices_ ) {} + vk::BufferCreateInfo & operator=( vk::BufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BufferCreateInfo( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BufferCreateInfo( rhs ) - {} + { + *this = rhs; + } BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BufferCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -23799,53 +23516,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BufferCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eBufferCreateInfo; + const void* pNext = nullptr; + vk::BufferCreateFlags flags; + vk::DeviceSize size; + vk::BufferUsageFlags usage; + vk::SharingMode sharingMode; + 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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BufferDeviceAddressCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( vk::DeviceAddress deviceAddress_ = 0 ) VULKAN_HPP_NOEXCEPT - : deviceAddress( deviceAddress_ ) - {} - - BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BufferDeviceAddressCreateInfoEXT& operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT; - const void* pNext = nullptr; - vk::DeviceAddress deviceAddress; - }; - static_assert( sizeof( BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct BufferDeviceAddressCreateInfoEXT : public layout::BufferDeviceAddressCreateInfoEXT + struct BufferDeviceAddressCreateInfoEXT { VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( vk::DeviceAddress deviceAddress_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::BufferDeviceAddressCreateInfoEXT( deviceAddress_ ) + : deviceAddress( deviceAddress_ ) {} + vk::BufferDeviceAddressCreateInfoEXT & operator=( vk::BufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferDeviceAddressCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BufferDeviceAddressCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } BufferDeviceAddressCreateInfoEXT& operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BufferDeviceAddressCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -23883,53 +23586,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BufferDeviceAddressCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT; + const void* pNext = nullptr; + vk::DeviceAddress deviceAddress; }; static_assert( sizeof( BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BufferDeviceAddressInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfoEXT( vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : buffer( buffer_ ) - {} - - BufferDeviceAddressInfoEXT( VkBufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BufferDeviceAddressInfoEXT& operator=( VkBufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBufferDeviceAddressInfoEXT; - const void* pNext = nullptr; - vk::Buffer buffer; - }; - static_assert( sizeof( BufferDeviceAddressInfoEXT ) == sizeof( VkBufferDeviceAddressInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct BufferDeviceAddressInfoEXT : public layout::BufferDeviceAddressInfoEXT + struct BufferDeviceAddressInfoEXT { VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfoEXT( vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : layout::BufferDeviceAddressInfoEXT( buffer_ ) + : buffer( buffer_ ) {} + vk::BufferDeviceAddressInfoEXT & operator=( vk::BufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferDeviceAddressInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + BufferDeviceAddressInfoEXT( VkBufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BufferDeviceAddressInfoEXT( rhs ) - {} + { + *this = rhs; + } BufferDeviceAddressInfoEXT& operator=( VkBufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BufferDeviceAddressInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -23967,8 +23651,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BufferDeviceAddressInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eBufferDeviceAddressInfoEXT; + const void* pNext = nullptr; + vk::Buffer buffer; }; static_assert( sizeof( BufferDeviceAddressInfoEXT ) == sizeof( VkBufferDeviceAddressInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -23987,12 +23673,12 @@ namespace VULKAN_HPP_NAMESPACE ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -24070,12 +23756,12 @@ namespace VULKAN_HPP_NAMESPACE BufferImageCopy( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } BufferImageCopy& operator=( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -24151,53 +23837,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BufferMemoryBarrier - { - protected: - VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(), - vk::AccessFlags dstAccessMask_ = vk::AccessFlags(), - uint32_t srcQueueFamilyIndex_ = 0, - uint32_t dstQueueFamilyIndex_ = 0, - vk::Buffer buffer_ = vk::Buffer(), - vk::DeviceSize offset_ = 0, - vk::DeviceSize size_ = 0 ) VULKAN_HPP_NOEXCEPT - : srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) - , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) - , buffer( buffer_ ) - , offset( offset_ ) - , size( size_ ) - {} - - BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBufferMemoryBarrier; - const void* pNext = nullptr; - vk::AccessFlags srcAccessMask; - vk::AccessFlags dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - vk::Buffer buffer; - vk::DeviceSize offset; - vk::DeviceSize size; - }; - static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "layout struct and wrapper have different size!" ); - } - - struct BufferMemoryBarrier : public layout::BufferMemoryBarrier + struct BufferMemoryBarrier { VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(), vk::AccessFlags dstAccessMask_ = vk::AccessFlags(), @@ -24206,16 +23846,29 @@ namespace VULKAN_HPP_NAMESPACE vk::Buffer buffer_ = vk::Buffer(), vk::DeviceSize offset_ = 0, vk::DeviceSize size_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::BufferMemoryBarrier( srcAccessMask_, dstAccessMask_, srcQueueFamilyIndex_, dstQueueFamilyIndex_, buffer_, offset_, size_ ) + : srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) + , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) + , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) + , buffer( buffer_ ) + , offset( offset_ ) + , size( size_ ) {} + vk::BufferMemoryBarrier & operator=( vk::BufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferMemoryBarrier ) - sizeof( vk::StructureType ) ); + return *this; + } + BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BufferMemoryBarrier( rhs ) - {} + { + *this = rhs; + } BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BufferMemoryBarrier::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -24295,53 +23948,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BufferMemoryBarrier::sType; + public: + const vk::StructureType sType = StructureType::eBufferMemoryBarrier; + const void* pNext = nullptr; + vk::AccessFlags srcAccessMask; + vk::AccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + vk::Buffer buffer; + vk::DeviceSize offset; + vk::DeviceSize size; }; static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BufferMemoryRequirementsInfo2 - { - protected: - VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : buffer( buffer_ ) - {} - - BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBufferMemoryRequirementsInfo2; - const void* pNext = nullptr; - vk::Buffer buffer; - }; - static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "layout struct and wrapper have different size!" ); - } - - struct BufferMemoryRequirementsInfo2 : public layout::BufferMemoryRequirementsInfo2 + struct BufferMemoryRequirementsInfo2 { VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : layout::BufferMemoryRequirementsInfo2( buffer_ ) + : buffer( buffer_ ) {} + vk::BufferMemoryRequirementsInfo2 & operator=( vk::BufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferMemoryRequirementsInfo2 ) - sizeof( vk::StructureType ) ); + return *this; + } + BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BufferMemoryRequirementsInfo2( rhs ) - {} + { + *this = rhs; + } BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BufferMemoryRequirementsInfo2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -24379,69 +24019,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BufferMemoryRequirementsInfo2::sType; + public: + const vk::StructureType sType = StructureType::eBufferMemoryRequirementsInfo2; + const void* pNext = nullptr; + vk::Buffer buffer; }; static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct BufferViewCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( vk::BufferViewCreateFlags flags_ = vk::BufferViewCreateFlags(), - vk::Buffer buffer_ = vk::Buffer(), - vk::Format format_ = vk::Format::eUndefined, - vk::DeviceSize offset_ = 0, - vk::DeviceSize range_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , buffer( buffer_ ) - , format( format_ ) - , offset( offset_ ) - , range( range_ ) - {} - - BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eBufferViewCreateInfo; - const void* pNext = nullptr; - vk::BufferViewCreateFlags flags; - vk::Buffer buffer; - vk::Format format; - vk::DeviceSize offset; - vk::DeviceSize range; - }; - static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct BufferViewCreateInfo : public layout::BufferViewCreateInfo + struct BufferViewCreateInfo { VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( vk::BufferViewCreateFlags flags_ = vk::BufferViewCreateFlags(), vk::Buffer buffer_ = vk::Buffer(), vk::Format format_ = vk::Format::eUndefined, vk::DeviceSize offset_ = 0, vk::DeviceSize range_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::BufferViewCreateInfo( flags_, buffer_, format_, offset_, range_ ) + : flags( flags_ ) + , buffer( buffer_ ) + , format( format_ ) + , offset( offset_ ) + , range( range_ ) {} + vk::BufferViewCreateInfo & operator=( vk::BufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::BufferViewCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::BufferViewCreateInfo( rhs ) - {} + { + *this = rhs; + } BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::BufferViewCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -24507,53 +24120,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::BufferViewCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eBufferViewCreateInfo; + const void* pNext = nullptr; + vk::BufferViewCreateFlags flags; + vk::Buffer buffer; + vk::Format format; + vk::DeviceSize offset; + vk::DeviceSize range; }; static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CalibratedTimestampInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoEXT( vk::TimeDomainEXT timeDomain_ = vk::TimeDomainEXT::eDevice ) VULKAN_HPP_NOEXCEPT - : timeDomain( timeDomain_ ) - {} - - CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCalibratedTimestampInfoEXT; - const void* pNext = nullptr; - vk::TimeDomainEXT timeDomain; - }; - static_assert( sizeof( CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct CalibratedTimestampInfoEXT : public layout::CalibratedTimestampInfoEXT + struct CalibratedTimestampInfoEXT { VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoEXT( vk::TimeDomainEXT timeDomain_ = vk::TimeDomainEXT::eDevice ) VULKAN_HPP_NOEXCEPT - : layout::CalibratedTimestampInfoEXT( timeDomain_ ) + : timeDomain( timeDomain_ ) {} + vk::CalibratedTimestampInfoEXT & operator=( vk::CalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CalibratedTimestampInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + CalibratedTimestampInfoEXT( VkCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CalibratedTimestampInfoEXT( rhs ) - {} + { + *this = rhs; + } CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CalibratedTimestampInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -24591,53 +24189,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CalibratedTimestampInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eCalibratedTimestampInfoEXT; + const void* pNext = nullptr; + vk::TimeDomainEXT timeDomain; }; static_assert( sizeof( CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct CheckpointDataNV { - struct CheckpointDataNV - { - protected: - CheckpointDataNV() VULKAN_HPP_NOEXCEPT - {} - - CheckpointDataNV( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CheckpointDataNV& operator=( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCheckpointDataNV; - void* pNext = nullptr; - vk::PipelineStageFlagBits stage; - void* pCheckpointMarker; - }; - static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "layout struct and wrapper have different size!" ); - } - - struct CheckpointDataNV : public layout::CheckpointDataNV - { - CheckpointDataNV() VULKAN_HPP_NOEXCEPT - : layout::CheckpointDataNV() + CheckpointDataNV( vk::PipelineStageFlagBits stage_ = vk::PipelineStageFlagBits::eTopOfPipe, + void* pCheckpointMarker_ = nullptr ) VULKAN_HPP_NOEXCEPT + : stage( stage_ ) + , pCheckpointMarker( pCheckpointMarker_ ) {} + vk::CheckpointDataNV & operator=( vk::CheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CheckpointDataNV ) - sizeof( vk::StructureType ) ); + return *this; + } + CheckpointDataNV( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CheckpointDataNV( rhs ) - {} + { + *this = rhs; + } CheckpointDataNV& operator=( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CheckpointDataNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -24664,8 +24245,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CheckpointDataNV::sType; + public: + const vk::StructureType sType = StructureType::eCheckpointDataNV; + void* pNext = nullptr; + vk::PipelineStageFlagBits stage; + void* pCheckpointMarker; }; static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -24729,12 +24313,12 @@ namespace VULKAN_HPP_NAMESPACE ClearDepthStencilValue( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -24832,12 +24416,12 @@ namespace VULKAN_HPP_NAMESPACE ClearAttachment( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ClearAttachment& operator=( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -24889,12 +24473,12 @@ namespace VULKAN_HPP_NAMESPACE ClearRect( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ClearRect& operator=( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -24958,12 +24542,12 @@ namespace VULKAN_HPP_NAMESPACE IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -25015,62 +24599,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CmdProcessCommandsInfoNVX - { - protected: - VULKAN_HPP_CONSTEXPR CmdProcessCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(), - vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(), - uint32_t indirectCommandsTokenCount_ = 0, - const vk::IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr, - uint32_t maxSequencesCount_ = 0, - vk::CommandBuffer targetCommandBuffer_ = vk::CommandBuffer(), - vk::Buffer sequencesCountBuffer_ = vk::Buffer(), - vk::DeviceSize sequencesCountOffset_ = 0, - vk::Buffer sequencesIndexBuffer_ = vk::Buffer(), - vk::DeviceSize sequencesIndexOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : objectTable( objectTable_ ) - , indirectCommandsLayout( indirectCommandsLayout_ ) - , indirectCommandsTokenCount( indirectCommandsTokenCount_ ) - , pIndirectCommandsTokens( pIndirectCommandsTokens_ ) - , maxSequencesCount( maxSequencesCount_ ) - , targetCommandBuffer( targetCommandBuffer_ ) - , sequencesCountBuffer( sequencesCountBuffer_ ) - , sequencesCountOffset( sequencesCountOffset_ ) - , sequencesIndexBuffer( sequencesIndexBuffer_ ) - , sequencesIndexOffset( sequencesIndexOffset_ ) - {} - - CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCmdProcessCommandsInfoNVX; - const void* pNext = nullptr; - vk::ObjectTableNVX objectTable; - vk::IndirectCommandsLayoutNVX indirectCommandsLayout; - uint32_t indirectCommandsTokenCount; - const vk::IndirectCommandsTokenNVX* pIndirectCommandsTokens; - uint32_t maxSequencesCount; - vk::CommandBuffer targetCommandBuffer; - vk::Buffer sequencesCountBuffer; - vk::DeviceSize sequencesCountOffset; - vk::Buffer sequencesIndexBuffer; - vk::DeviceSize sequencesIndexOffset; - }; - static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "layout struct and wrapper have different size!" ); - } - - struct CmdProcessCommandsInfoNVX : public layout::CmdProcessCommandsInfoNVX + struct CmdProcessCommandsInfoNVX { VULKAN_HPP_CONSTEXPR CmdProcessCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(), vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(), @@ -25082,16 +24611,32 @@ namespace VULKAN_HPP_NAMESPACE vk::DeviceSize sequencesCountOffset_ = 0, vk::Buffer sequencesIndexBuffer_ = vk::Buffer(), vk::DeviceSize sequencesIndexOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::CmdProcessCommandsInfoNVX( objectTable_, indirectCommandsLayout_, indirectCommandsTokenCount_, pIndirectCommandsTokens_, maxSequencesCount_, targetCommandBuffer_, sequencesCountBuffer_, sequencesCountOffset_, sequencesIndexBuffer_, sequencesIndexOffset_ ) + : objectTable( objectTable_ ) + , indirectCommandsLayout( indirectCommandsLayout_ ) + , indirectCommandsTokenCount( indirectCommandsTokenCount_ ) + , pIndirectCommandsTokens( pIndirectCommandsTokens_ ) + , maxSequencesCount( maxSequencesCount_ ) + , targetCommandBuffer( targetCommandBuffer_ ) + , sequencesCountBuffer( sequencesCountBuffer_ ) + , sequencesCountOffset( sequencesCountOffset_ ) + , sequencesIndexBuffer( sequencesIndexBuffer_ ) + , sequencesIndexOffset( sequencesIndexOffset_ ) {} + vk::CmdProcessCommandsInfoNVX & operator=( vk::CmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CmdProcessCommandsInfoNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CmdProcessCommandsInfoNVX( rhs ) - {} + { + *this = rhs; + } CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CmdProcessCommandsInfoNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -25192,61 +24737,47 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CmdProcessCommandsInfoNVX::sType; + public: + const vk::StructureType sType = StructureType::eCmdProcessCommandsInfoNVX; + const void* pNext = nullptr; + vk::ObjectTableNVX objectTable; + vk::IndirectCommandsLayoutNVX indirectCommandsLayout; + uint32_t indirectCommandsTokenCount; + const vk::IndirectCommandsTokenNVX* pIndirectCommandsTokens; + uint32_t maxSequencesCount; + vk::CommandBuffer targetCommandBuffer; + vk::Buffer sequencesCountBuffer; + vk::DeviceSize sequencesCountOffset; + vk::Buffer sequencesIndexBuffer; + vk::DeviceSize sequencesIndexOffset; }; static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CmdReserveSpaceForCommandsInfoNVX - { - protected: - VULKAN_HPP_CONSTEXPR CmdReserveSpaceForCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(), - vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(), - uint32_t maxSequencesCount_ = 0 ) VULKAN_HPP_NOEXCEPT - : objectTable( objectTable_ ) - , indirectCommandsLayout( indirectCommandsLayout_ ) - , maxSequencesCount( maxSequencesCount_ ) - {} - - CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX; - const void* pNext = nullptr; - vk::ObjectTableNVX objectTable; - vk::IndirectCommandsLayoutNVX indirectCommandsLayout; - uint32_t maxSequencesCount; - }; - static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "layout struct and wrapper have different size!" ); - } - - struct CmdReserveSpaceForCommandsInfoNVX : public layout::CmdReserveSpaceForCommandsInfoNVX + struct CmdReserveSpaceForCommandsInfoNVX { VULKAN_HPP_CONSTEXPR CmdReserveSpaceForCommandsInfoNVX( vk::ObjectTableNVX objectTable_ = vk::ObjectTableNVX(), vk::IndirectCommandsLayoutNVX indirectCommandsLayout_ = vk::IndirectCommandsLayoutNVX(), uint32_t maxSequencesCount_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::CmdReserveSpaceForCommandsInfoNVX( objectTable_, indirectCommandsLayout_, maxSequencesCount_ ) + : objectTable( objectTable_ ) + , indirectCommandsLayout( indirectCommandsLayout_ ) + , maxSequencesCount( maxSequencesCount_ ) {} + vk::CmdReserveSpaceForCommandsInfoNVX & operator=( vk::CmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CmdReserveSpaceForCommandsInfoNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CmdReserveSpaceForCommandsInfoNVX( rhs ) - {} + { + *this = rhs; + } CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CmdReserveSpaceForCommandsInfoNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -25298,8 +24829,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CmdReserveSpaceForCommandsInfoNVX::sType; + public: + const vk::StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX; + const void* pNext = nullptr; + vk::ObjectTableNVX objectTable; + vk::IndirectCommandsLayoutNVX indirectCommandsLayout; + uint32_t maxSequencesCount; }; static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -25316,12 +24851,12 @@ namespace VULKAN_HPP_NAMESPACE CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } CoarseSampleLocationNV& operator=( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -25387,12 +24922,12 @@ namespace VULKAN_HPP_NAMESPACE CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } CoarseSampleOrderCustomNV& operator=( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -25452,55 +24987,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( CoarseSampleOrderCustomNV ) == sizeof( VkCoarseSampleOrderCustomNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CommandBufferAllocateInfo - { - protected: - VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( vk::CommandPool commandPool_ = vk::CommandPool(), - vk::CommandBufferLevel level_ = vk::CommandBufferLevel::ePrimary, - uint32_t commandBufferCount_ = 0 ) VULKAN_HPP_NOEXCEPT - : commandPool( commandPool_ ) - , level( level_ ) - , commandBufferCount( commandBufferCount_ ) - {} - - CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCommandBufferAllocateInfo; - const void* pNext = nullptr; - vk::CommandPool commandPool; - vk::CommandBufferLevel level; - uint32_t commandBufferCount; - }; - static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "layout struct and wrapper have different size!" ); - } - - struct CommandBufferAllocateInfo : public layout::CommandBufferAllocateInfo + struct CommandBufferAllocateInfo { VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( vk::CommandPool commandPool_ = vk::CommandPool(), vk::CommandBufferLevel level_ = vk::CommandBufferLevel::ePrimary, uint32_t commandBufferCount_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferAllocateInfo( commandPool_, level_, commandBufferCount_ ) + : commandPool( commandPool_ ) + , level( level_ ) + , commandBufferCount( commandBufferCount_ ) {} + vk::CommandBufferAllocateInfo & operator=( vk::CommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandBufferAllocateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferAllocateInfo( rhs ) - {} + { + *this = rhs; + } CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CommandBufferAllocateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -25552,56 +25062,17 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CommandBufferAllocateInfo::sType; + public: + const vk::StructureType sType = StructureType::eCommandBufferAllocateInfo; + const void* pNext = nullptr; + vk::CommandPool commandPool; + vk::CommandBufferLevel level; + uint32_t commandBufferCount; }; static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CommandBufferInheritanceInfo - { - protected: - VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( vk::RenderPass renderPass_ = vk::RenderPass(), - uint32_t subpass_ = 0, - vk::Framebuffer framebuffer_ = vk::Framebuffer(), - vk::Bool32 occlusionQueryEnable_ = 0, - vk::QueryControlFlags queryFlags_ = vk::QueryControlFlags(), - vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() ) VULKAN_HPP_NOEXCEPT - : renderPass( renderPass_ ) - , subpass( subpass_ ) - , framebuffer( framebuffer_ ) - , occlusionQueryEnable( occlusionQueryEnable_ ) - , queryFlags( queryFlags_ ) - , pipelineStatistics( pipelineStatistics_ ) - {} - - CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCommandBufferInheritanceInfo; - const void* pNext = nullptr; - vk::RenderPass renderPass; - uint32_t subpass; - vk::Framebuffer framebuffer; - vk::Bool32 occlusionQueryEnable; - vk::QueryControlFlags queryFlags; - vk::QueryPipelineStatisticFlags pipelineStatistics; - }; - static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "layout struct and wrapper have different size!" ); - } - - struct CommandBufferInheritanceInfo : public layout::CommandBufferInheritanceInfo + struct CommandBufferInheritanceInfo { VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( vk::RenderPass renderPass_ = vk::RenderPass(), uint32_t subpass_ = 0, @@ -25609,16 +25080,28 @@ namespace VULKAN_HPP_NAMESPACE vk::Bool32 occlusionQueryEnable_ = 0, vk::QueryControlFlags queryFlags_ = vk::QueryControlFlags(), vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferInheritanceInfo( renderPass_, subpass_, framebuffer_, occlusionQueryEnable_, queryFlags_, pipelineStatistics_ ) + : renderPass( renderPass_ ) + , subpass( subpass_ ) + , framebuffer( framebuffer_ ) + , occlusionQueryEnable( occlusionQueryEnable_ ) + , queryFlags( queryFlags_ ) + , pipelineStatistics( pipelineStatistics_ ) {} + vk::CommandBufferInheritanceInfo & operator=( vk::CommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandBufferInheritanceInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferInheritanceInfo( rhs ) - {} + { + *this = rhs; + } CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CommandBufferInheritanceInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -25691,57 +25174,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CommandBufferInheritanceInfo::sType; + public: + const vk::StructureType sType = StructureType::eCommandBufferInheritanceInfo; + const void* pNext = nullptr; + vk::RenderPass renderPass; + uint32_t subpass; + vk::Framebuffer framebuffer; + vk::Bool32 occlusionQueryEnable; + vk::QueryControlFlags queryFlags; + vk::QueryPipelineStatisticFlags pipelineStatistics; }; static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CommandBufferBeginInfo - { - protected: - VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( vk::CommandBufferUsageFlags flags_ = vk::CommandBufferUsageFlags(), - const vk::CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pInheritanceInfo( pInheritanceInfo_ ) - {} - - CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCommandBufferBeginInfo; - const void* pNext = nullptr; - vk::CommandBufferUsageFlags flags; - const vk::CommandBufferInheritanceInfo* pInheritanceInfo; - }; - static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "layout struct and wrapper have different size!" ); - } - - struct CommandBufferBeginInfo : public layout::CommandBufferBeginInfo + struct CommandBufferBeginInfo { VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( vk::CommandBufferUsageFlags flags_ = vk::CommandBufferUsageFlags(), const vk::CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferBeginInfo( flags_, pInheritanceInfo_ ) + : flags( flags_ ) + , pInheritanceInfo( pInheritanceInfo_ ) {} + vk::CommandBufferBeginInfo & operator=( vk::CommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandBufferBeginInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferBeginInfo( rhs ) - {} + { + *this = rhs; + } CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CommandBufferBeginInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -25786,53 +25253,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CommandBufferBeginInfo::sType; + public: + const vk::StructureType sType = StructureType::eCommandBufferBeginInfo; + const void* pNext = nullptr; + vk::CommandBufferUsageFlags flags; + const vk::CommandBufferInheritanceInfo* pInheritanceInfo; }; static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CommandBufferInheritanceConditionalRenderingInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( vk::Bool32 conditionalRenderingEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : conditionalRenderingEnable( conditionalRenderingEnable_ ) - {} - - CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CommandBufferInheritanceConditionalRenderingInfoEXT& operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT; - const void* pNext = nullptr; - vk::Bool32 conditionalRenderingEnable; - }; - static_assert( sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) == sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct CommandBufferInheritanceConditionalRenderingInfoEXT : public layout::CommandBufferInheritanceConditionalRenderingInfoEXT + struct CommandBufferInheritanceConditionalRenderingInfoEXT { VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( vk::Bool32 conditionalRenderingEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferInheritanceConditionalRenderingInfoEXT( conditionalRenderingEnable_ ) + : conditionalRenderingEnable( conditionalRenderingEnable_ ) {} + vk::CommandBufferInheritanceConditionalRenderingInfoEXT & operator=( vk::CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandBufferInheritanceConditionalRenderingInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CommandBufferInheritanceConditionalRenderingInfoEXT( rhs ) - {} + { + *this = rhs; + } CommandBufferInheritanceConditionalRenderingInfoEXT& operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CommandBufferInheritanceConditionalRenderingInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -25870,57 +25319,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CommandBufferInheritanceConditionalRenderingInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT; + const void* pNext = nullptr; + vk::Bool32 conditionalRenderingEnable; }; static_assert( sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) == sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CommandPoolCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( vk::CommandPoolCreateFlags flags_ = vk::CommandPoolCreateFlags(), - uint32_t queueFamilyIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , queueFamilyIndex( queueFamilyIndex_ ) - {} - - CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCommandPoolCreateInfo; - const void* pNext = nullptr; - vk::CommandPoolCreateFlags flags; - uint32_t queueFamilyIndex; - }; - static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct CommandPoolCreateInfo : public layout::CommandPoolCreateInfo + struct CommandPoolCreateInfo { VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( vk::CommandPoolCreateFlags flags_ = vk::CommandPoolCreateFlags(), uint32_t queueFamilyIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::CommandPoolCreateInfo( flags_, queueFamilyIndex_ ) + : flags( flags_ ) + , queueFamilyIndex( queueFamilyIndex_ ) {} + vk::CommandPoolCreateInfo & operator=( vk::CommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CommandPoolCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CommandPoolCreateInfo( rhs ) - {} + { + *this = rhs; + } CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CommandPoolCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -25965,8 +25393,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CommandPoolCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eCommandPoolCreateInfo; + const void* pNext = nullptr; + vk::CommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; }; static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -25983,12 +25414,12 @@ namespace VULKAN_HPP_NAMESPACE SpecializationMapEntry( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -26054,12 +25485,12 @@ namespace VULKAN_HPP_NAMESPACE SpecializationInfo( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SpecializationInfo& operator=( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -26119,63 +25550,34 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineShaderStageCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( vk::PipelineShaderStageCreateFlags flags_ = vk::PipelineShaderStageCreateFlags(), - vk::ShaderStageFlagBits stage_ = vk::ShaderStageFlagBits::eVertex, - vk::ShaderModule module_ = vk::ShaderModule(), - const char* pName_ = nullptr, - const vk::SpecializationInfo* pSpecializationInfo_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , stage( stage_ ) - , module( module_ ) - , pName( pName_ ) - , pSpecializationInfo( pSpecializationInfo_ ) - {} - - PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineShaderStageCreateInfo; - const void* pNext = nullptr; - vk::PipelineShaderStageCreateFlags flags; - vk::ShaderStageFlagBits stage; - vk::ShaderModule module; - const char* pName; - const vk::SpecializationInfo* pSpecializationInfo; - }; - static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineShaderStageCreateInfo : public layout::PipelineShaderStageCreateInfo + struct PipelineShaderStageCreateInfo { VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( vk::PipelineShaderStageCreateFlags flags_ = vk::PipelineShaderStageCreateFlags(), vk::ShaderStageFlagBits stage_ = vk::ShaderStageFlagBits::eVertex, vk::ShaderModule module_ = vk::ShaderModule(), const char* pName_ = nullptr, const vk::SpecializationInfo* pSpecializationInfo_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineShaderStageCreateInfo( flags_, stage_, module_, pName_, pSpecializationInfo_ ) + : flags( flags_ ) + , stage( stage_ ) + , module( module_ ) + , pName( pName_ ) + , pSpecializationInfo( pSpecializationInfo_ ) {} + vk::PipelineShaderStageCreateInfo & operator=( vk::PipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineShaderStageCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineShaderStageCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineShaderStageCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -26241,69 +25643,46 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineShaderStageCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineShaderStageCreateInfo; + const void* pNext = nullptr; + vk::PipelineShaderStageCreateFlags flags; + vk::ShaderStageFlagBits stage; + vk::ShaderModule module; + const char* pName; + const vk::SpecializationInfo* pSpecializationInfo; }; static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ComputePipelineCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(), - vk::PipelineShaderStageCreateInfo stage_ = vk::PipelineShaderStageCreateInfo(), - vk::PipelineLayout layout_ = vk::PipelineLayout(), - vk::Pipeline basePipelineHandle_ = vk::Pipeline(), - int32_t basePipelineIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , stage( stage_ ) - , layout( layout_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - {} - - ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eComputePipelineCreateInfo; - const void* pNext = nullptr; - vk::PipelineCreateFlags flags; - vk::PipelineShaderStageCreateInfo stage; - vk::PipelineLayout layout; - vk::Pipeline basePipelineHandle; - int32_t basePipelineIndex; - }; - static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ComputePipelineCreateInfo : public layout::ComputePipelineCreateInfo + struct ComputePipelineCreateInfo { VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(), vk::PipelineShaderStageCreateInfo stage_ = vk::PipelineShaderStageCreateInfo(), vk::PipelineLayout layout_ = vk::PipelineLayout(), vk::Pipeline basePipelineHandle_ = vk::Pipeline(), int32_t basePipelineIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ComputePipelineCreateInfo( flags_, stage_, layout_, basePipelineHandle_, basePipelineIndex_ ) + : flags( flags_ ) + , stage( stage_ ) + , layout( layout_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) {} + vk::ComputePipelineCreateInfo & operator=( vk::ComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ComputePipelineCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ComputePipelineCreateInfo( rhs ) - {} + { + *this = rhs; + } ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ComputePipelineCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -26369,61 +25748,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ComputePipelineCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eComputePipelineCreateInfo; + const void* pNext = nullptr; + vk::PipelineCreateFlags flags; + vk::PipelineShaderStageCreateInfo stage; + vk::PipelineLayout layout; + vk::Pipeline basePipelineHandle; + int32_t basePipelineIndex; }; static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ConditionalRenderingBeginInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( vk::Buffer buffer_ = vk::Buffer(), - vk::DeviceSize offset_ = 0, - vk::ConditionalRenderingFlagsEXT flags_ = vk::ConditionalRenderingFlagsEXT() ) VULKAN_HPP_NOEXCEPT - : buffer( buffer_ ) - , offset( offset_ ) - , flags( flags_ ) - {} - - ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT; - const void* pNext = nullptr; - vk::Buffer buffer; - vk::DeviceSize offset; - vk::ConditionalRenderingFlagsEXT flags; - }; - static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct ConditionalRenderingBeginInfoEXT : public layout::ConditionalRenderingBeginInfoEXT + struct ConditionalRenderingBeginInfoEXT { VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( vk::Buffer buffer_ = vk::Buffer(), vk::DeviceSize offset_ = 0, vk::ConditionalRenderingFlagsEXT flags_ = vk::ConditionalRenderingFlagsEXT() ) VULKAN_HPP_NOEXCEPT - : layout::ConditionalRenderingBeginInfoEXT( buffer_, offset_, flags_ ) + : buffer( buffer_ ) + , offset( offset_ ) + , flags( flags_ ) {} + vk::ConditionalRenderingBeginInfoEXT & operator=( vk::ConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ConditionalRenderingBeginInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ConditionalRenderingBeginInfoEXT( rhs ) - {} + { + *this = rhs; + } ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ConditionalRenderingBeginInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -26475,8 +25835,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ConditionalRenderingBeginInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT; + const void* pNext = nullptr; + vk::Buffer buffer; + vk::DeviceSize offset; + vk::ConditionalRenderingFlagsEXT flags; }; static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -26495,12 +25859,12 @@ namespace VULKAN_HPP_NAMESPACE ConformanceVersionKHR( VkConformanceVersionKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ConformanceVersionKHR& operator=( VkConformanceVersionKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -26560,56 +25924,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ConformanceVersionKHR ) == sizeof( VkConformanceVersionKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CooperativeMatrixPropertiesNV - { - protected: - VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( uint32_t MSize_ = 0, - uint32_t NSize_ = 0, - uint32_t KSize_ = 0, - vk::ComponentTypeNV AType_ = vk::ComponentTypeNV::eFloat16, - vk::ComponentTypeNV BType_ = vk::ComponentTypeNV::eFloat16, - vk::ComponentTypeNV CType_ = vk::ComponentTypeNV::eFloat16, - vk::ComponentTypeNV DType_ = vk::ComponentTypeNV::eFloat16, - vk::ScopeNV scope_ = vk::ScopeNV::eDevice ) VULKAN_HPP_NOEXCEPT - : MSize( MSize_ ) - , NSize( NSize_ ) - , KSize( KSize_ ) - , AType( AType_ ) - , BType( BType_ ) - , CType( CType_ ) - , DType( DType_ ) - , scope( scope_ ) - {} - - CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CooperativeMatrixPropertiesNV& operator=( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCooperativeMatrixPropertiesNV; - void* pNext = nullptr; - uint32_t MSize; - uint32_t NSize; - uint32_t KSize; - vk::ComponentTypeNV AType; - vk::ComponentTypeNV BType; - vk::ComponentTypeNV CType; - vk::ComponentTypeNV DType; - vk::ScopeNV scope; - }; - static_assert( sizeof( CooperativeMatrixPropertiesNV ) == sizeof( VkCooperativeMatrixPropertiesNV ), "layout struct and wrapper have different size!" ); - } - - struct CooperativeMatrixPropertiesNV : public layout::CooperativeMatrixPropertiesNV + struct CooperativeMatrixPropertiesNV { VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( uint32_t MSize_ = 0, uint32_t NSize_ = 0, @@ -26619,16 +25934,30 @@ namespace VULKAN_HPP_NAMESPACE vk::ComponentTypeNV CType_ = vk::ComponentTypeNV::eFloat16, vk::ComponentTypeNV DType_ = vk::ComponentTypeNV::eFloat16, vk::ScopeNV scope_ = vk::ScopeNV::eDevice ) VULKAN_HPP_NOEXCEPT - : layout::CooperativeMatrixPropertiesNV( MSize_, NSize_, KSize_, AType_, BType_, CType_, DType_, scope_ ) + : MSize( MSize_ ) + , NSize( NSize_ ) + , KSize( KSize_ ) + , AType( AType_ ) + , BType( BType_ ) + , CType( CType_ ) + , DType( DType_ ) + , scope( scope_ ) {} + vk::CooperativeMatrixPropertiesNV & operator=( vk::CooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CooperativeMatrixPropertiesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CooperativeMatrixPropertiesNV( rhs ) - {} + { + *this = rhs; + } CooperativeMatrixPropertiesNV& operator=( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CooperativeMatrixPropertiesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -26715,59 +26044,22 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CooperativeMatrixPropertiesNV::sType; + public: + const vk::StructureType sType = StructureType::eCooperativeMatrixPropertiesNV; + void* pNext = nullptr; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + vk::ComponentTypeNV AType; + vk::ComponentTypeNV BType; + vk::ComponentTypeNV CType; + vk::ComponentTypeNV DType; + vk::ScopeNV scope; }; static_assert( sizeof( CooperativeMatrixPropertiesNV ) == sizeof( VkCooperativeMatrixPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct CopyDescriptorSet - { - protected: - VULKAN_HPP_CONSTEXPR CopyDescriptorSet( vk::DescriptorSet srcSet_ = vk::DescriptorSet(), - uint32_t srcBinding_ = 0, - uint32_t srcArrayElement_ = 0, - vk::DescriptorSet dstSet_ = vk::DescriptorSet(), - uint32_t dstBinding_ = 0, - uint32_t dstArrayElement_ = 0, - uint32_t descriptorCount_ = 0 ) VULKAN_HPP_NOEXCEPT - : srcSet( srcSet_ ) - , srcBinding( srcBinding_ ) - , srcArrayElement( srcArrayElement_ ) - , dstSet( dstSet_ ) - , dstBinding( dstBinding_ ) - , dstArrayElement( dstArrayElement_ ) - , descriptorCount( descriptorCount_ ) - {} - - CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eCopyDescriptorSet; - const void* pNext = nullptr; - vk::DescriptorSet srcSet; - uint32_t srcBinding; - uint32_t srcArrayElement; - vk::DescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - }; - static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "layout struct and wrapper have different size!" ); - } - - struct CopyDescriptorSet : public layout::CopyDescriptorSet + struct CopyDescriptorSet { VULKAN_HPP_CONSTEXPR CopyDescriptorSet( vk::DescriptorSet srcSet_ = vk::DescriptorSet(), uint32_t srcBinding_ = 0, @@ -26776,16 +26068,29 @@ namespace VULKAN_HPP_NAMESPACE uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::CopyDescriptorSet( srcSet_, srcBinding_, srcArrayElement_, dstSet_, dstBinding_, dstArrayElement_, descriptorCount_ ) + : srcSet( srcSet_ ) + , srcBinding( srcBinding_ ) + , srcArrayElement( srcArrayElement_ ) + , dstSet( dstSet_ ) + , dstBinding( dstBinding_ ) + , dstArrayElement( dstArrayElement_ ) + , descriptorCount( descriptorCount_ ) {} + vk::CopyDescriptorSet & operator=( vk::CopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::CopyDescriptorSet ) - sizeof( vk::StructureType ) ); + return *this; + } + CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::CopyDescriptorSet( rhs ) - {} + { + *this = rhs; + } CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::CopyDescriptorSet::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -26865,67 +26170,48 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::CopyDescriptorSet::sType; + public: + const vk::StructureType sType = StructureType::eCopyDescriptorSet; + const void* pNext = nullptr; + vk::DescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + vk::DescriptorSet dstSet; + 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::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct D3D12FenceSubmitInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0, - const uint64_t* pWaitSemaphoreValues_ = nullptr, - uint32_t signalSemaphoreValuesCount_ = 0, - const uint64_t* pSignalSemaphoreValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ ) - , pWaitSemaphoreValues( pWaitSemaphoreValues_ ) - , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ ) - , pSignalSemaphoreValues( pSignalSemaphoreValues_ ) - {} - - D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR; - const void* pNext = nullptr; - uint32_t waitSemaphoreValuesCount; - const uint64_t* pWaitSemaphoreValues; - uint32_t signalSemaphoreValuesCount; - const uint64_t* pSignalSemaphoreValues; - }; - static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct D3D12FenceSubmitInfoKHR : public layout::D3D12FenceSubmitInfoKHR + struct D3D12FenceSubmitInfoKHR { VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0, const uint64_t* pWaitSemaphoreValues_ = nullptr, uint32_t signalSemaphoreValuesCount_ = 0, const uint64_t* pSignalSemaphoreValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::D3D12FenceSubmitInfoKHR( waitSemaphoreValuesCount_, pWaitSemaphoreValues_, signalSemaphoreValuesCount_, pSignalSemaphoreValues_ ) + : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ ) + , pWaitSemaphoreValues( pWaitSemaphoreValues_ ) + , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ ) + , pSignalSemaphoreValues( pSignalSemaphoreValues_ ) {} + vk::D3D12FenceSubmitInfoKHR & operator=( vk::D3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::D3D12FenceSubmitInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::D3D12FenceSubmitInfoKHR( rhs ) - {} + { + *this = rhs; + } D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::D3D12FenceSubmitInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -26984,60 +26270,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::D3D12FenceSubmitInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR; + const void* pNext = nullptr; + uint32_t waitSemaphoreValuesCount; + 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::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct DebugMarkerMarkerInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr, - std::array const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT - : pMarkerName( pMarkerName_ ) - , color{} - { - vk::ConstExpressionArrayCopy::copy( color, color_ ); - } - - DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT; - const void* pNext = nullptr; - const char* pMarkerName; - float color[4]; - }; - static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugMarkerMarkerInfoEXT : public layout::DebugMarkerMarkerInfoEXT + struct DebugMarkerMarkerInfoEXT { VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr, std::array const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT - : layout::DebugMarkerMarkerInfoEXT( pMarkerName_, color_ ) - {} + : pMarkerName( pMarkerName_ ) + , color{} + { + vk::ConstExpressionArrayCopy::copy( color, color_ ); + } + + vk::DebugMarkerMarkerInfoEXT & operator=( vk::DebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugMarkerMarkerInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugMarkerMarkerInfoEXT( rhs ) - {} + { + *this = rhs; + } DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugMarkerMarkerInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27082,61 +26350,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugMarkerMarkerInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT; + const void* pNext = nullptr; + const char* pMarkerName; + float color[4]; }; static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugMarkerObjectNameInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown, - uint64_t object_ = 0, - const char* pObjectName_ = nullptr ) VULKAN_HPP_NOEXCEPT - : objectType( objectType_ ) - , object( object_ ) - , pObjectName( pObjectName_ ) - {} - - DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT; - const void* pNext = nullptr; - vk::DebugReportObjectTypeEXT objectType; - uint64_t object; - const char* pObjectName; - }; - static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugMarkerObjectNameInfoEXT : public layout::DebugMarkerObjectNameInfoEXT + struct DebugMarkerObjectNameInfoEXT { VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, const char* pObjectName_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DebugMarkerObjectNameInfoEXT( objectType_, object_, pObjectName_ ) + : objectType( objectType_ ) + , object( object_ ) + , pObjectName( pObjectName_ ) {} + vk::DebugMarkerObjectNameInfoEXT & operator=( vk::DebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugMarkerObjectNameInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugMarkerObjectNameInfoEXT( rhs ) - {} + { + *this = rhs; + } DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugMarkerObjectNameInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27188,69 +26434,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugMarkerObjectNameInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT; + const void* pNext = nullptr; + vk::DebugReportObjectTypeEXT objectType; + uint64_t object; + const char* pObjectName; }; static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugMarkerObjectTagInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown, - uint64_t object_ = 0, - uint64_t tagName_ = 0, - size_t tagSize_ = 0, - const void* pTag_ = nullptr ) VULKAN_HPP_NOEXCEPT - : objectType( objectType_ ) - , object( object_ ) - , tagName( tagName_ ) - , tagSize( tagSize_ ) - , pTag( pTag_ ) - {} - - DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT; - const void* pNext = nullptr; - vk::DebugReportObjectTypeEXT objectType; - uint64_t object; - uint64_t tagName; - size_t tagSize; - const void* pTag; - }; - static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugMarkerObjectTagInfoEXT : public layout::DebugMarkerObjectTagInfoEXT + struct DebugMarkerObjectTagInfoEXT { VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( vk::DebugReportObjectTypeEXT objectType_ = vk::DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, uint64_t tagName_ = 0, size_t tagSize_ = 0, const void* pTag_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DebugMarkerObjectTagInfoEXT( objectType_, object_, tagName_, tagSize_, pTag_ ) + : objectType( objectType_ ) + , object( object_ ) + , tagName( tagName_ ) + , tagSize( tagSize_ ) + , pTag( pTag_ ) {} + vk::DebugMarkerObjectTagInfoEXT & operator=( vk::DebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugMarkerObjectTagInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugMarkerObjectTagInfoEXT( rhs ) - {} + { + *this = rhs; + } DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugMarkerObjectTagInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27316,61 +26537,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugMarkerObjectTagInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT; + const void* pNext = nullptr; + vk::DebugReportObjectTypeEXT objectType; + uint64_t object; + 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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugReportCallbackCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( vk::DebugReportFlagsEXT flags_ = vk::DebugReportFlagsEXT(), - PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, - void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pfnCallback( pfnCallback_ ) - , pUserData( pUserData_ ) - {} - - DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT; - const void* pNext = nullptr; - vk::DebugReportFlagsEXT flags; - PFN_vkDebugReportCallbackEXT pfnCallback; - void* pUserData; - }; - static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugReportCallbackCreateInfoEXT : public layout::DebugReportCallbackCreateInfoEXT + struct DebugReportCallbackCreateInfoEXT { VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( vk::DebugReportFlagsEXT flags_ = vk::DebugReportFlagsEXT(), PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DebugReportCallbackCreateInfoEXT( flags_, pfnCallback_, pUserData_ ) + : flags( flags_ ) + , pfnCallback( pfnCallback_ ) + , pUserData( pUserData_ ) {} + vk::DebugReportCallbackCreateInfoEXT & operator=( vk::DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugReportCallbackCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugReportCallbackCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugReportCallbackCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27422,59 +26624,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugReportCallbackCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT; + const void* pNext = nullptr; + vk::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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugUtilsLabelEXT - { - protected: - VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( const char* pLabelName_ = nullptr, - std::array const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT - : pLabelName( pLabelName_ ) - , color{} - { - vk::ConstExpressionArrayCopy::copy( color, color_ ); - } - - DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugUtilsLabelEXT; - const void* pNext = nullptr; - const char* pLabelName; - float color[4]; - }; - static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugUtilsLabelEXT : public layout::DebugUtilsLabelEXT + struct DebugUtilsLabelEXT { VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( const char* pLabelName_ = nullptr, std::array const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsLabelEXT( pLabelName_, color_ ) - {} + : pLabelName( pLabelName_ ) + , color{} + { + vk::ConstExpressionArrayCopy::copy( color, color_ ); + } + + vk::DebugUtilsLabelEXT & operator=( vk::DebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsLabelEXT ) - sizeof( vk::StructureType ) ); + return *this; + } DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsLabelEXT( rhs ) - {} + { + *this = rhs; + } DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugUtilsLabelEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27519,61 +26702,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugUtilsLabelEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugUtilsLabelEXT; + const void* pNext = nullptr; + const char* pLabelName; + float color[4]; }; static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugUtilsObjectNameInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown, - uint64_t objectHandle_ = 0, - const char* pObjectName_ = nullptr ) VULKAN_HPP_NOEXCEPT - : objectType( objectType_ ) - , objectHandle( objectHandle_ ) - , pObjectName( pObjectName_ ) - {} - - DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT; - const void* pNext = nullptr; - vk::ObjectType objectType; - uint64_t objectHandle; - const char* pObjectName; - }; - static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugUtilsObjectNameInfoEXT : public layout::DebugUtilsObjectNameInfoEXT + struct DebugUtilsObjectNameInfoEXT { VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown, uint64_t objectHandle_ = 0, const char* pObjectName_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsObjectNameInfoEXT( objectType_, objectHandle_, pObjectName_ ) + : objectType( objectType_ ) + , objectHandle( objectHandle_ ) + , pObjectName( pObjectName_ ) {} + vk::DebugUtilsObjectNameInfoEXT & operator=( vk::DebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsObjectNameInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsObjectNameInfoEXT( rhs ) - {} + { + *this = rhs; + } DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugUtilsObjectNameInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27625,68 +26786,17 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugUtilsObjectNameInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT; + const void* pNext = nullptr; + vk::ObjectType objectType; + uint64_t objectHandle; + const char* pObjectName; }; static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugUtilsMessengerCallbackDataEXT - { - protected: - VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCallbackDataEXT( vk::DebugUtilsMessengerCallbackDataFlagsEXT flags_ = vk::DebugUtilsMessengerCallbackDataFlagsEXT(), - const char* pMessageIdName_ = nullptr, - int32_t messageIdNumber_ = 0, - const char* pMessage_ = nullptr, - uint32_t queueLabelCount_ = 0, - const vk::DebugUtilsLabelEXT* pQueueLabels_ = nullptr, - uint32_t cmdBufLabelCount_ = 0, - const vk::DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr, - uint32_t objectCount_ = 0, - const vk::DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pMessageIdName( pMessageIdName_ ) - , messageIdNumber( messageIdNumber_ ) - , pMessage( pMessage_ ) - , queueLabelCount( queueLabelCount_ ) - , pQueueLabels( pQueueLabels_ ) - , cmdBufLabelCount( cmdBufLabelCount_ ) - , pCmdBufLabels( pCmdBufLabels_ ) - , objectCount( objectCount_ ) - , pObjects( pObjects_ ) - {} - - DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT; - const void* pNext = nullptr; - vk::DebugUtilsMessengerCallbackDataFlagsEXT flags; - const char* pMessageIdName; - int32_t messageIdNumber; - const char* pMessage; - uint32_t queueLabelCount; - const vk::DebugUtilsLabelEXT* pQueueLabels; - uint32_t cmdBufLabelCount; - const vk::DebugUtilsLabelEXT* pCmdBufLabels; - uint32_t objectCount; - const vk::DebugUtilsObjectNameInfoEXT* pObjects; - }; - static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugUtilsMessengerCallbackDataEXT : public layout::DebugUtilsMessengerCallbackDataEXT + struct DebugUtilsMessengerCallbackDataEXT { VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCallbackDataEXT( vk::DebugUtilsMessengerCallbackDataFlagsEXT flags_ = vk::DebugUtilsMessengerCallbackDataFlagsEXT(), const char* pMessageIdName_ = nullptr, @@ -27698,16 +26808,32 @@ namespace VULKAN_HPP_NAMESPACE const vk::DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr, uint32_t objectCount_ = 0, const vk::DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsMessengerCallbackDataEXT( flags_, pMessageIdName_, messageIdNumber_, pMessage_, queueLabelCount_, pQueueLabels_, cmdBufLabelCount_, pCmdBufLabels_, objectCount_, pObjects_ ) + : flags( flags_ ) + , pMessageIdName( pMessageIdName_ ) + , messageIdNumber( messageIdNumber_ ) + , pMessage( pMessage_ ) + , queueLabelCount( queueLabelCount_ ) + , pQueueLabels( pQueueLabels_ ) + , cmdBufLabelCount( cmdBufLabelCount_ ) + , pCmdBufLabels( pCmdBufLabels_ ) + , objectCount( objectCount_ ) + , pObjects( pObjects_ ) {} + vk::DebugUtilsMessengerCallbackDataEXT & operator=( vk::DebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsMessengerCallbackDataEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsMessengerCallbackDataEXT( rhs ) - {} + { + *this = rhs; + } DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugUtilsMessengerCallbackDataEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27808,69 +26934,51 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugUtilsMessengerCallbackDataEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT; + const void* pNext = nullptr; + vk::DebugUtilsMessengerCallbackDataFlagsEXT flags; + const char* pMessageIdName; + int32_t messageIdNumber; + const char* pMessage; + uint32_t queueLabelCount; + const vk::DebugUtilsLabelEXT* pQueueLabels; + uint32_t cmdBufLabelCount; + const vk::DebugUtilsLabelEXT* pCmdBufLabels; + uint32_t objectCount; + const vk::DebugUtilsObjectNameInfoEXT* pObjects; }; static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugUtilsMessengerCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( vk::DebugUtilsMessengerCreateFlagsEXT flags_ = vk::DebugUtilsMessengerCreateFlagsEXT(), - vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = vk::DebugUtilsMessageSeverityFlagsEXT(), - vk::DebugUtilsMessageTypeFlagsEXT messageType_ = vk::DebugUtilsMessageTypeFlagsEXT(), - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr, - void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , messageSeverity( messageSeverity_ ) - , messageType( messageType_ ) - , pfnUserCallback( pfnUserCallback_ ) - , pUserData( pUserData_ ) - {} - - DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT; - const void* pNext = nullptr; - vk::DebugUtilsMessengerCreateFlagsEXT flags; - vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity; - vk::DebugUtilsMessageTypeFlagsEXT messageType; - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; - void* pUserData; - }; - static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugUtilsMessengerCreateInfoEXT : public layout::DebugUtilsMessengerCreateInfoEXT + struct DebugUtilsMessengerCreateInfoEXT { VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( vk::DebugUtilsMessengerCreateFlagsEXT flags_ = vk::DebugUtilsMessengerCreateFlagsEXT(), vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = vk::DebugUtilsMessageSeverityFlagsEXT(), vk::DebugUtilsMessageTypeFlagsEXT messageType_ = vk::DebugUtilsMessageTypeFlagsEXT(), PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr, void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsMessengerCreateInfoEXT( flags_, messageSeverity_, messageType_, pfnUserCallback_, pUserData_ ) + : flags( flags_ ) + , messageSeverity( messageSeverity_ ) + , messageType( messageType_ ) + , pfnUserCallback( pfnUserCallback_ ) + , pUserData( pUserData_ ) {} + vk::DebugUtilsMessengerCreateInfoEXT & operator=( vk::DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsMessengerCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsMessengerCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugUtilsMessengerCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -27936,69 +27044,46 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugUtilsMessengerCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT; + const void* pNext = nullptr; + vk::DebugUtilsMessengerCreateFlagsEXT flags; + vk::DebugUtilsMessageSeverityFlagsEXT messageSeverity; + vk::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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DebugUtilsObjectTagInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown, - uint64_t objectHandle_ = 0, - uint64_t tagName_ = 0, - size_t tagSize_ = 0, - const void* pTag_ = nullptr ) VULKAN_HPP_NOEXCEPT - : objectType( objectType_ ) - , objectHandle( objectHandle_ ) - , tagName( tagName_ ) - , tagSize( tagSize_ ) - , pTag( pTag_ ) - {} - - DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT; - const void* pNext = nullptr; - vk::ObjectType objectType; - uint64_t objectHandle; - uint64_t tagName; - size_t tagSize; - const void* pTag; - }; - static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DebugUtilsObjectTagInfoEXT : public layout::DebugUtilsObjectTagInfoEXT + struct DebugUtilsObjectTagInfoEXT { VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( vk::ObjectType objectType_ = vk::ObjectType::eUnknown, uint64_t objectHandle_ = 0, uint64_t tagName_ = 0, size_t tagSize_ = 0, const void* pTag_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsObjectTagInfoEXT( objectType_, objectHandle_, tagName_, tagSize_, pTag_ ) + : objectType( objectType_ ) + , objectHandle( objectHandle_ ) + , tagName( tagName_ ) + , tagSize( tagSize_ ) + , pTag( pTag_ ) {} + vk::DebugUtilsObjectTagInfoEXT & operator=( vk::DebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DebugUtilsObjectTagInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DebugUtilsObjectTagInfoEXT( rhs ) - {} + { + *this = rhs; + } DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DebugUtilsObjectTagInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -28064,53 +27149,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DebugUtilsObjectTagInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT; + const void* pNext = nullptr; + vk::ObjectType objectType; + uint64_t objectHandle; + 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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DedicatedAllocationBufferCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : dedicatedAllocation( dedicatedAllocation_ ) - {} - - DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV; - const void* pNext = nullptr; - vk::Bool32 dedicatedAllocation; - }; - static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct DedicatedAllocationBufferCreateInfoNV : public layout::DedicatedAllocationBufferCreateInfoNV + struct DedicatedAllocationBufferCreateInfoNV { VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DedicatedAllocationBufferCreateInfoNV( dedicatedAllocation_ ) + : dedicatedAllocation( dedicatedAllocation_ ) {} + vk::DedicatedAllocationBufferCreateInfoNV & operator=( vk::DedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DedicatedAllocationBufferCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DedicatedAllocationBufferCreateInfoNV( rhs ) - {} + { + *this = rhs; + } DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DedicatedAllocationBufferCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -28148,53 +27218,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DedicatedAllocationBufferCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV; + const void* pNext = nullptr; + vk::Bool32 dedicatedAllocation; }; static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DedicatedAllocationImageCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : dedicatedAllocation( dedicatedAllocation_ ) - {} - - DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV; - const void* pNext = nullptr; - vk::Bool32 dedicatedAllocation; - }; - static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct DedicatedAllocationImageCreateInfoNV : public layout::DedicatedAllocationImageCreateInfoNV + struct DedicatedAllocationImageCreateInfoNV { VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( vk::Bool32 dedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DedicatedAllocationImageCreateInfoNV( dedicatedAllocation_ ) + : dedicatedAllocation( dedicatedAllocation_ ) {} + vk::DedicatedAllocationImageCreateInfoNV & operator=( vk::DedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DedicatedAllocationImageCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DedicatedAllocationImageCreateInfoNV( rhs ) - {} + { + *this = rhs; + } DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DedicatedAllocationImageCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -28232,57 +27283,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DedicatedAllocationImageCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV; + const void* pNext = nullptr; + vk::Bool32 dedicatedAllocation; }; static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DedicatedAllocationMemoryAllocateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( vk::Image image_ = vk::Image(), - vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : image( image_ ) - , buffer( buffer_ ) - {} - - DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV; - const void* pNext = nullptr; - vk::Image image; - vk::Buffer buffer; - }; - static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct DedicatedAllocationMemoryAllocateInfoNV : public layout::DedicatedAllocationMemoryAllocateInfoNV + struct DedicatedAllocationMemoryAllocateInfoNV { VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( vk::Image image_ = vk::Image(), vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : layout::DedicatedAllocationMemoryAllocateInfoNV( image_, buffer_ ) + : image( image_ ) + , buffer( buffer_ ) {} + vk::DedicatedAllocationMemoryAllocateInfoNV & operator=( vk::DedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DedicatedAllocationMemoryAllocateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DedicatedAllocationMemoryAllocateInfoNV( rhs ) - {} + { + *this = rhs; + } DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DedicatedAllocationMemoryAllocateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -28327,8 +27357,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DedicatedAllocationMemoryAllocateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV; + const void* pNext = nullptr; + vk::Image image; + vk::Buffer buffer; }; static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -28345,12 +27378,12 @@ namespace VULKAN_HPP_NAMESPACE DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -28414,12 +27447,12 @@ namespace VULKAN_HPP_NAMESPACE DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -28481,12 +27514,12 @@ namespace VULKAN_HPP_NAMESPACE DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -28530,59 +27563,32 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DescriptorPoolCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( vk::DescriptorPoolCreateFlags flags_ = vk::DescriptorPoolCreateFlags(), - uint32_t maxSets_ = 0, - uint32_t poolSizeCount_ = 0, - const vk::DescriptorPoolSize* pPoolSizes_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , maxSets( maxSets_ ) - , poolSizeCount( poolSizeCount_ ) - , pPoolSizes( pPoolSizes_ ) - {} - - DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorPoolCreateInfo; - const void* pNext = nullptr; - vk::DescriptorPoolCreateFlags flags; - uint32_t maxSets; - uint32_t poolSizeCount; - const vk::DescriptorPoolSize* pPoolSizes; - }; - static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorPoolCreateInfo : public layout::DescriptorPoolCreateInfo + struct DescriptorPoolCreateInfo { VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( vk::DescriptorPoolCreateFlags flags_ = vk::DescriptorPoolCreateFlags(), uint32_t maxSets_ = 0, uint32_t poolSizeCount_ = 0, const vk::DescriptorPoolSize* pPoolSizes_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorPoolCreateInfo( flags_, maxSets_, poolSizeCount_, pPoolSizes_ ) + : flags( flags_ ) + , maxSets( maxSets_ ) + , poolSizeCount( poolSizeCount_ ) + , pPoolSizes( pPoolSizes_ ) {} + vk::DescriptorPoolCreateInfo & operator=( vk::DescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorPoolCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorPoolCreateInfo( rhs ) - {} + { + *this = rhs; + } DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorPoolCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -28641,53 +27647,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorPoolCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorPoolCreateInfo; + const void* pNext = nullptr; + vk::DescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const vk::DescriptorPoolSize* pPoolSizes; }; static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DescriptorPoolInlineUniformBlockCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 ) VULKAN_HPP_NOEXCEPT - : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ ) - {} - - DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT; - const void* pNext = nullptr; - uint32_t maxInlineUniformBlockBindings; - }; - static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorPoolInlineUniformBlockCreateInfoEXT : public layout::DescriptorPoolInlineUniformBlockCreateInfoEXT + struct DescriptorPoolInlineUniformBlockCreateInfoEXT { VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorPoolInlineUniformBlockCreateInfoEXT( maxInlineUniformBlockBindings_ ) + : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ ) {} + vk::DescriptorPoolInlineUniformBlockCreateInfoEXT & operator=( vk::DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorPoolInlineUniformBlockCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorPoolInlineUniformBlockCreateInfoEXT( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorPoolInlineUniformBlockCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorPoolInlineUniformBlockCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -28725,61 +27715,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorPoolInlineUniformBlockCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT; + const void* pNext = nullptr; + uint32_t maxInlineUniformBlockBindings; }; static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DescriptorSetAllocateInfo - { - protected: - VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( vk::DescriptorPool descriptorPool_ = vk::DescriptorPool(), - uint32_t descriptorSetCount_ = 0, - const vk::DescriptorSetLayout* pSetLayouts_ = nullptr ) VULKAN_HPP_NOEXCEPT - : descriptorPool( descriptorPool_ ) - , descriptorSetCount( descriptorSetCount_ ) - , pSetLayouts( pSetLayouts_ ) - {} - - DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorSetAllocateInfo; - const void* pNext = nullptr; - vk::DescriptorPool descriptorPool; - uint32_t descriptorSetCount; - const vk::DescriptorSetLayout* pSetLayouts; - }; - static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorSetAllocateInfo : public layout::DescriptorSetAllocateInfo + struct DescriptorSetAllocateInfo { VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( vk::DescriptorPool descriptorPool_ = vk::DescriptorPool(), uint32_t descriptorSetCount_ = 0, const vk::DescriptorSetLayout* pSetLayouts_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetAllocateInfo( descriptorPool_, descriptorSetCount_, pSetLayouts_ ) + : descriptorPool( descriptorPool_ ) + , descriptorSetCount( descriptorSetCount_ ) + , pSetLayouts( pSetLayouts_ ) {} + vk::DescriptorSetAllocateInfo & operator=( vk::DescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetAllocateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetAllocateInfo( rhs ) - {} + { + *this = rhs; + } DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorSetAllocateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -28831,8 +27798,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorSetAllocateInfo::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorSetAllocateInfo; + const void* pNext = nullptr; + vk::DescriptorPool descriptorPool; + uint32_t descriptorSetCount; + const vk::DescriptorSetLayout* pSetLayouts; }; static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -28853,12 +27824,12 @@ namespace VULKAN_HPP_NAMESPACE DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -28926,51 +27897,28 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DescriptorSetLayoutBindingFlagsCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0, - const vk::DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr ) VULKAN_HPP_NOEXCEPT - : bindingCount( bindingCount_ ) - , pBindingFlags( pBindingFlags_ ) - {} - - DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT; - const void* pNext = nullptr; - uint32_t bindingCount; - const vk::DescriptorBindingFlagsEXT* pBindingFlags; - }; - static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorSetLayoutBindingFlagsCreateInfoEXT : public layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT + struct DescriptorSetLayoutBindingFlagsCreateInfoEXT { VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfoEXT( uint32_t bindingCount_ = 0, const vk::DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT( bindingCount_, pBindingFlags_ ) + : bindingCount( bindingCount_ ) + , pBindingFlags( pBindingFlags_ ) {} + vk::DescriptorSetLayoutBindingFlagsCreateInfoEXT & operator=( vk::DescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetLayoutBindingFlagsCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorSetLayoutBindingFlagsCreateInfoEXT( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -29015,61 +27963,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorSetLayoutBindingFlagsCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT; + const void* pNext = nullptr; + uint32_t bindingCount; + const vk::DescriptorBindingFlagsEXT* pBindingFlags; }; static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DescriptorSetLayoutCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( vk::DescriptorSetLayoutCreateFlags flags_ = vk::DescriptorSetLayoutCreateFlags(), - uint32_t bindingCount_ = 0, - const vk::DescriptorSetLayoutBinding* pBindings_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , bindingCount( bindingCount_ ) - , pBindings( pBindings_ ) - {} - - DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo; - const void* pNext = nullptr; - vk::DescriptorSetLayoutCreateFlags flags; - uint32_t bindingCount; - const vk::DescriptorSetLayoutBinding* pBindings; - }; - static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorSetLayoutCreateInfo : public layout::DescriptorSetLayoutCreateInfo + struct DescriptorSetLayoutCreateInfo { VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( vk::DescriptorSetLayoutCreateFlags flags_ = vk::DescriptorSetLayoutCreateFlags(), uint32_t bindingCount_ = 0, const vk::DescriptorSetLayoutBinding* pBindings_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetLayoutCreateInfo( flags_, bindingCount_, pBindings_ ) + : flags( flags_ ) + , bindingCount( bindingCount_ ) + , pBindings( pBindings_ ) {} + vk::DescriptorSetLayoutCreateInfo & operator=( vk::DescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetLayoutCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetLayoutCreateInfo( rhs ) - {} + { + *this = rhs; + } DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorSetLayoutCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -29121,52 +28047,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorSetLayoutCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo; + const void* pNext = nullptr; + vk::DescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const vk::DescriptorSetLayoutBinding* pBindings; }; static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DescriptorSetLayoutSupport { - struct DescriptorSetLayoutSupport - { - protected: - DescriptorSetLayoutSupport() VULKAN_HPP_NOEXCEPT - {} - - DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorSetLayoutSupport& operator=( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorSetLayoutSupport; - void* pNext = nullptr; - vk::Bool32 supported; - }; - static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorSetLayoutSupport : public layout::DescriptorSetLayoutSupport - { - DescriptorSetLayoutSupport() VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetLayoutSupport() + DescriptorSetLayoutSupport( vk::Bool32 supported_ = 0 ) VULKAN_HPP_NOEXCEPT + : supported( supported_ ) {} + vk::DescriptorSetLayoutSupport & operator=( vk::DescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetLayoutSupport ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetLayoutSupport( rhs ) - {} + { + *this = rhs; + } DescriptorSetLayoutSupport& operator=( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorSetLayoutSupport::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -29192,57 +28102,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorSetLayoutSupport::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorSetLayoutSupport; + void* pNext = nullptr; + vk::Bool32 supported; }; static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DescriptorSetVariableDescriptorCountAllocateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0, - const uint32_t* pDescriptorCounts_ = nullptr ) VULKAN_HPP_NOEXCEPT - : descriptorSetCount( descriptorSetCount_ ) - , pDescriptorCounts( pDescriptorCounts_ ) - {} - - DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT; - const void* pNext = nullptr; - uint32_t descriptorSetCount; - const uint32_t* pDescriptorCounts; - }; - static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorSetVariableDescriptorCountAllocateInfoEXT : public layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT + struct DescriptorSetVariableDescriptorCountAllocateInfoEXT { VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfoEXT( uint32_t descriptorSetCount_ = 0, const uint32_t* pDescriptorCounts_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT( descriptorSetCount_, pDescriptorCounts_ ) + : descriptorSetCount( descriptorSetCount_ ) + , pDescriptorCounts( pDescriptorCounts_ ) {} + vk::DescriptorSetVariableDescriptorCountAllocateInfoEXT & operator=( vk::DescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetVariableDescriptorCountAllocateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorSetVariableDescriptorCountAllocateInfoEXT( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT( rhs ) - {} + { + *this = rhs; + } DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -29287,52 +28176,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorSetVariableDescriptorCountAllocateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT; + const void* pNext = nullptr; + uint32_t descriptorSetCount; + const uint32_t* pDescriptorCounts; }; static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DescriptorSetVariableDescriptorCountLayoutSupportEXT { - struct DescriptorSetVariableDescriptorCountLayoutSupportEXT - { - protected: - DescriptorSetVariableDescriptorCountLayoutSupportEXT() VULKAN_HPP_NOEXCEPT - {} - - DescriptorSetVariableDescriptorCountLayoutSupportEXT( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorSetVariableDescriptorCountLayoutSupportEXT& operator=( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT; - void* pNext = nullptr; - uint32_t maxVariableDescriptorCount; - }; - static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorSetVariableDescriptorCountLayoutSupportEXT : public layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT - { - DescriptorSetVariableDescriptorCountLayoutSupportEXT() VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT() + DescriptorSetVariableDescriptorCountLayoutSupportEXT( uint32_t maxVariableDescriptorCount_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxVariableDescriptorCount( maxVariableDescriptorCount_ ) {} + vk::DescriptorSetVariableDescriptorCountLayoutSupportEXT & operator=( vk::DescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorSetVariableDescriptorCountLayoutSupportEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorSetVariableDescriptorCountLayoutSupportEXT( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT( rhs ) - {} + { + *this = rhs; + } DescriptorSetVariableDescriptorCountLayoutSupportEXT& operator=( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -29358,8 +28230,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorSetVariableDescriptorCountLayoutSupportEXT::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT; + void* pNext = nullptr; + uint32_t maxVariableDescriptorCount; }; static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -29382,12 +28256,12 @@ namespace VULKAN_HPP_NAMESPACE DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DescriptorUpdateTemplateEntry& operator=( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -29463,56 +28337,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DescriptorUpdateTemplateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( vk::DescriptorUpdateTemplateCreateFlags flags_ = vk::DescriptorUpdateTemplateCreateFlags(), - uint32_t descriptorUpdateEntryCount_ = 0, - const vk::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr, - vk::DescriptorUpdateTemplateType templateType_ = vk::DescriptorUpdateTemplateType::eDescriptorSet, - vk::DescriptorSetLayout descriptorSetLayout_ = vk::DescriptorSetLayout(), - vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics, - vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(), - uint32_t set_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ ) - , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ ) - , templateType( templateType_ ) - , descriptorSetLayout( descriptorSetLayout_ ) - , pipelineBindPoint( pipelineBindPoint_ ) - , pipelineLayout( pipelineLayout_ ) - , set( set_ ) - {} - - DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo; - const void* pNext = nullptr; - vk::DescriptorUpdateTemplateCreateFlags flags; - uint32_t descriptorUpdateEntryCount; - const vk::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; - vk::DescriptorUpdateTemplateType templateType; - vk::DescriptorSetLayout descriptorSetLayout; - vk::PipelineBindPoint pipelineBindPoint; - vk::PipelineLayout pipelineLayout; - uint32_t set; - }; - static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct DescriptorUpdateTemplateCreateInfo : public layout::DescriptorUpdateTemplateCreateInfo + struct DescriptorUpdateTemplateCreateInfo { VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( vk::DescriptorUpdateTemplateCreateFlags flags_ = vk::DescriptorUpdateTemplateCreateFlags(), uint32_t descriptorUpdateEntryCount_ = 0, @@ -29522,16 +28347,30 @@ namespace VULKAN_HPP_NAMESPACE vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics, vk::PipelineLayout pipelineLayout_ = vk::PipelineLayout(), uint32_t set_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorUpdateTemplateCreateInfo( flags_, descriptorUpdateEntryCount_, pDescriptorUpdateEntries_, templateType_, descriptorSetLayout_, pipelineBindPoint_, pipelineLayout_, set_ ) + : flags( flags_ ) + , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ ) + , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ ) + , templateType( templateType_ ) + , descriptorSetLayout( descriptorSetLayout_ ) + , pipelineBindPoint( pipelineBindPoint_ ) + , pipelineLayout( pipelineLayout_ ) + , set( set_ ) {} + vk::DescriptorUpdateTemplateCreateInfo & operator=( vk::DescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DescriptorUpdateTemplateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DescriptorUpdateTemplateCreateInfo( rhs ) - {} + { + *this = rhs; + } DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DescriptorUpdateTemplateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -29618,65 +28457,47 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DescriptorUpdateTemplateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo; + const void* pNext = nullptr; + vk::DescriptorUpdateTemplateCreateFlags flags; + uint32_t descriptorUpdateEntryCount; + const vk::DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; + vk::DescriptorUpdateTemplateType templateType; + vk::DescriptorSetLayout descriptorSetLayout; + vk::PipelineBindPoint pipelineBindPoint; + vk::PipelineLayout pipelineLayout; + uint32_t set; }; static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceQueueCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(), - uint32_t queueFamilyIndex_ = 0, - uint32_t queueCount_ = 0, - const float* pQueuePriorities_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , queueFamilyIndex( queueFamilyIndex_ ) - , queueCount( queueCount_ ) - , pQueuePriorities( pQueuePriorities_ ) - {} - - DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceQueueCreateInfo; - const void* pNext = nullptr; - vk::DeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueCount; - const float* pQueuePriorities; - }; - static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct DeviceQueueCreateInfo : public layout::DeviceQueueCreateInfo + struct DeviceQueueCreateInfo { VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(), uint32_t queueFamilyIndex_ = 0, uint32_t queueCount_ = 0, const float* pQueuePriorities_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DeviceQueueCreateInfo( flags_, queueFamilyIndex_, queueCount_, pQueuePriorities_ ) + : flags( flags_ ) + , queueFamilyIndex( queueFamilyIndex_ ) + , queueCount( queueCount_ ) + , pQueuePriorities( pQueuePriorities_ ) {} + vk::DeviceQueueCreateInfo & operator=( vk::DeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceQueueCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceQueueCreateInfo( rhs ) - {} + { + *this = rhs; + } DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceQueueCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -29735,8 +28556,13 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceQueueCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eDeviceQueueCreateInfo; + const void* pNext = nullptr; + vk::DeviceQueueCreateFlags flags; + 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::value, "struct wrapper is not a standard layout!" ); @@ -29857,12 +28683,12 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -30330,56 +29156,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR DeviceCreateInfo( vk::DeviceCreateFlags flags_ = vk::DeviceCreateFlags(), - uint32_t queueCreateInfoCount_ = 0, - const vk::DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr, - uint32_t enabledLayerCount_ = 0, - const char* const* ppEnabledLayerNames_ = nullptr, - uint32_t enabledExtensionCount_ = 0, - const char* const* ppEnabledExtensionNames_ = nullptr, - const vk::PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , queueCreateInfoCount( queueCreateInfoCount_ ) - , pQueueCreateInfos( pQueueCreateInfos_ ) - , enabledLayerCount( enabledLayerCount_ ) - , ppEnabledLayerNames( ppEnabledLayerNames_ ) - , enabledExtensionCount( enabledExtensionCount_ ) - , ppEnabledExtensionNames( ppEnabledExtensionNames_ ) - , pEnabledFeatures( pEnabledFeatures_ ) - {} - - DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceCreateInfo; - const void* pNext = nullptr; - vk::DeviceCreateFlags flags; - uint32_t queueCreateInfoCount; - const vk::DeviceQueueCreateInfo* pQueueCreateInfos; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; - const vk::PhysicalDeviceFeatures* pEnabledFeatures; - }; - static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct DeviceCreateInfo : public layout::DeviceCreateInfo + struct DeviceCreateInfo { VULKAN_HPP_CONSTEXPR DeviceCreateInfo( vk::DeviceCreateFlags flags_ = vk::DeviceCreateFlags(), uint32_t queueCreateInfoCount_ = 0, @@ -30389,16 +29166,30 @@ namespace VULKAN_HPP_NAMESPACE uint32_t enabledExtensionCount_ = 0, const char* const* ppEnabledExtensionNames_ = nullptr, const vk::PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DeviceCreateInfo( flags_, queueCreateInfoCount_, pQueueCreateInfos_, enabledLayerCount_, ppEnabledLayerNames_, enabledExtensionCount_, ppEnabledExtensionNames_, pEnabledFeatures_ ) + : flags( flags_ ) + , queueCreateInfoCount( queueCreateInfoCount_ ) + , pQueueCreateInfos( pQueueCreateInfos_ ) + , enabledLayerCount( enabledLayerCount_ ) + , ppEnabledLayerNames( ppEnabledLayerNames_ ) + , enabledExtensionCount( enabledExtensionCount_ ) + , ppEnabledExtensionNames( ppEnabledExtensionNames_ ) + , pEnabledFeatures( pEnabledFeatures_ ) {} + vk::DeviceCreateInfo & operator=( vk::DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceCreateInfo( rhs ) - {} + { + *this = rhs; + } DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -30485,53 +29276,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eDeviceCreateInfo; + const void* pNext = nullptr; + vk::DeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + const vk::DeviceQueueCreateInfo* pQueueCreateInfos; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; + const vk::PhysicalDeviceFeatures* pEnabledFeatures; }; static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceEventInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( vk::DeviceEventTypeEXT deviceEvent_ = vk::DeviceEventTypeEXT::eDisplayHotplug ) VULKAN_HPP_NOEXCEPT - : deviceEvent( deviceEvent_ ) - {} - - DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceEventInfoEXT; - const void* pNext = nullptr; - vk::DeviceEventTypeEXT deviceEvent; - }; - static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DeviceEventInfoEXT : public layout::DeviceEventInfoEXT + struct DeviceEventInfoEXT { VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( vk::DeviceEventTypeEXT deviceEvent_ = vk::DeviceEventTypeEXT::eDisplayHotplug ) VULKAN_HPP_NOEXCEPT - : layout::DeviceEventInfoEXT( deviceEvent_ ) + : deviceEvent( deviceEvent_ ) {} + vk::DeviceEventInfoEXT & operator=( vk::DeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceEventInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceEventInfoEXT( rhs ) - {} + { + *this = rhs; + } DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceEventInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -30569,53 +29348,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceEventInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDeviceEventInfoEXT; + const void* pNext = nullptr; + vk::DeviceEventTypeEXT deviceEvent; }; static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGeneratedCommandsFeaturesNVX - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsFeaturesNVX( vk::Bool32 computeBindingPointSupport_ = 0 ) VULKAN_HPP_NOEXCEPT - : computeBindingPointSupport( computeBindingPointSupport_ ) - {} - - DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX; - const void* pNext = nullptr; - vk::Bool32 computeBindingPointSupport; - }; - static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGeneratedCommandsFeaturesNVX : public layout::DeviceGeneratedCommandsFeaturesNVX + struct DeviceGeneratedCommandsFeaturesNVX { VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsFeaturesNVX( vk::Bool32 computeBindingPointSupport_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGeneratedCommandsFeaturesNVX( computeBindingPointSupport_ ) + : computeBindingPointSupport( computeBindingPointSupport_ ) {} + vk::DeviceGeneratedCommandsFeaturesNVX & operator=( vk::DeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGeneratedCommandsFeaturesNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGeneratedCommandsFeaturesNVX( rhs ) - {} + { + *this = rhs; + } DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGeneratedCommandsFeaturesNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -30653,69 +29413,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGeneratedCommandsFeaturesNVX::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX; + const void* pNext = nullptr; + vk::Bool32 computeBindingPointSupport; }; static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGeneratedCommandsLimitsNVX - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0, - uint32_t maxObjectEntryCounts_ = 0, - uint32_t minSequenceCountBufferOffsetAlignment_ = 0, - uint32_t minSequenceIndexBufferOffsetAlignment_ = 0, - uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT - : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ ) - , maxObjectEntryCounts( maxObjectEntryCounts_ ) - , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ ) - , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ ) - , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ ) - {} - - DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX; - const void* pNext = nullptr; - uint32_t maxIndirectCommandsLayoutTokenCount; - uint32_t maxObjectEntryCounts; - uint32_t minSequenceCountBufferOffsetAlignment; - uint32_t minSequenceIndexBufferOffsetAlignment; - uint32_t minCommandsTokenBufferOffsetAlignment; - }; - static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGeneratedCommandsLimitsNVX : public layout::DeviceGeneratedCommandsLimitsNVX + struct DeviceGeneratedCommandsLimitsNVX { VULKAN_HPP_CONSTEXPR DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0, uint32_t maxObjectEntryCounts_ = 0, uint32_t minSequenceCountBufferOffsetAlignment_ = 0, uint32_t minSequenceIndexBufferOffsetAlignment_ = 0, uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGeneratedCommandsLimitsNVX( maxIndirectCommandsLayoutTokenCount_, maxObjectEntryCounts_, minSequenceCountBufferOffsetAlignment_, minSequenceIndexBufferOffsetAlignment_, minCommandsTokenBufferOffsetAlignment_ ) + : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ ) + , maxObjectEntryCounts( maxObjectEntryCounts_ ) + , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ ) + , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ ) + , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ ) {} + vk::DeviceGeneratedCommandsLimitsNVX & operator=( vk::DeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGeneratedCommandsLimitsNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGeneratedCommandsLimitsNVX( rhs ) - {} + { + *this = rhs; + } DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGeneratedCommandsLimitsNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -30781,57 +29514,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGeneratedCommandsLimitsNVX::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX; + const void* pNext = nullptr; + uint32_t maxIndirectCommandsLayoutTokenCount; + uint32_t maxObjectEntryCounts; + uint32_t minSequenceCountBufferOffsetAlignment; + uint32_t minSequenceIndexBufferOffsetAlignment; + uint32_t minCommandsTokenBufferOffsetAlignment; }; static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGroupBindSparseInfo - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0, - uint32_t memoryDeviceIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : resourceDeviceIndex( resourceDeviceIndex_ ) - , memoryDeviceIndex( memoryDeviceIndex_ ) - {} - - DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupBindSparseInfo; - const void* pNext = nullptr; - uint32_t resourceDeviceIndex; - uint32_t memoryDeviceIndex; - }; - static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupBindSparseInfo : public layout::DeviceGroupBindSparseInfo + struct DeviceGroupBindSparseInfo { VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0, uint32_t memoryDeviceIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupBindSparseInfo( resourceDeviceIndex_, memoryDeviceIndex_ ) + : resourceDeviceIndex( resourceDeviceIndex_ ) + , memoryDeviceIndex( memoryDeviceIndex_ ) {} + vk::DeviceGroupBindSparseInfo & operator=( vk::DeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupBindSparseInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupBindSparseInfo( rhs ) - {} + { + *this = rhs; + } DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupBindSparseInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -30876,53 +29592,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupBindSparseInfo::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupBindSparseInfo; + const void* pNext = nullptr; + uint32_t resourceDeviceIndex; + uint32_t memoryDeviceIndex; }; static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGroupCommandBufferBeginInfo - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT - : deviceMask( deviceMask_ ) - {} - - DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo; - const void* pNext = nullptr; - uint32_t deviceMask; - }; - static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupCommandBufferBeginInfo : public layout::DeviceGroupCommandBufferBeginInfo + struct DeviceGroupCommandBufferBeginInfo { VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupCommandBufferBeginInfo( deviceMask_ ) + : deviceMask( deviceMask_ ) {} + vk::DeviceGroupCommandBufferBeginInfo & operator=( vk::DeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupCommandBufferBeginInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupCommandBufferBeginInfo( rhs ) - {} + { + *this = rhs; + } DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupCommandBufferBeginInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -30960,57 +29658,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupCommandBufferBeginInfo::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo; + const void* pNext = nullptr; + uint32_t deviceMask; }; static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGroupDeviceCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0, - const vk::PhysicalDevice* pPhysicalDevices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : physicalDeviceCount( physicalDeviceCount_ ) - , pPhysicalDevices( pPhysicalDevices_ ) - {} - - DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo; - const void* pNext = nullptr; - uint32_t physicalDeviceCount; - const vk::PhysicalDevice* pPhysicalDevices; - }; - static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupDeviceCreateInfo : public layout::DeviceGroupDeviceCreateInfo + struct DeviceGroupDeviceCreateInfo { VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0, const vk::PhysicalDevice* pPhysicalDevices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupDeviceCreateInfo( physicalDeviceCount_, pPhysicalDevices_ ) + : physicalDeviceCount( physicalDeviceCount_ ) + , pPhysicalDevices( pPhysicalDevices_ ) {} + vk::DeviceGroupDeviceCreateInfo & operator=( vk::DeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupDeviceCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupDeviceCreateInfo( rhs ) - {} + { + *this = rhs; + } DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupDeviceCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31055,53 +29732,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupDeviceCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo; + const void* pNext = nullptr; + uint32_t physicalDeviceCount; + const vk::PhysicalDevice* pPhysicalDevices; }; static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DeviceGroupPresentCapabilitiesKHR { - struct DeviceGroupPresentCapabilitiesKHR + DeviceGroupPresentCapabilitiesKHR( std::array const& presentMask_ = { { 0 } }, + vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() ) VULKAN_HPP_NOEXCEPT + : presentMask{} + , modes( modes_ ) { - protected: - DeviceGroupPresentCapabilitiesKHR() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( presentMask, presentMask_ ); + } - DeviceGroupPresentCapabilitiesKHR( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupPresentCapabilitiesKHR& operator=( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR; - const void* pNext = nullptr; - uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; - vk::DeviceGroupPresentModeFlagsKHR modes; - }; - static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupPresentCapabilitiesKHR : public layout::DeviceGroupPresentCapabilitiesKHR - { - DeviceGroupPresentCapabilitiesKHR() VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupPresentCapabilitiesKHR() - {} + vk::DeviceGroupPresentCapabilitiesKHR & operator=( vk::DeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupPresentCapabilitiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } DeviceGroupPresentCapabilitiesKHR( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupPresentCapabilitiesKHR( rhs ) - {} + { + *this = rhs; + } DeviceGroupPresentCapabilitiesKHR& operator=( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupPresentCapabilitiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31128,61 +29791,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupPresentCapabilitiesKHR::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR; + const void* pNext = nullptr; + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; + vk::DeviceGroupPresentModeFlagsKHR modes; }; static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGroupPresentInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0, - const uint32_t* pDeviceMasks_ = nullptr, - vk::DeviceGroupPresentModeFlagBitsKHR mode_ = vk::DeviceGroupPresentModeFlagBitsKHR::eLocal ) VULKAN_HPP_NOEXCEPT - : swapchainCount( swapchainCount_ ) - , pDeviceMasks( pDeviceMasks_ ) - , mode( mode_ ) - {} - - DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupPresentInfoKHR; - const void* pNext = nullptr; - uint32_t swapchainCount; - const uint32_t* pDeviceMasks; - vk::DeviceGroupPresentModeFlagBitsKHR mode; - }; - static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupPresentInfoKHR : public layout::DeviceGroupPresentInfoKHR + struct DeviceGroupPresentInfoKHR { VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = 0, const uint32_t* pDeviceMasks_ = nullptr, vk::DeviceGroupPresentModeFlagBitsKHR mode_ = vk::DeviceGroupPresentModeFlagBitsKHR::eLocal ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupPresentInfoKHR( swapchainCount_, pDeviceMasks_, mode_ ) + : swapchainCount( swapchainCount_ ) + , pDeviceMasks( pDeviceMasks_ ) + , mode( mode_ ) {} + vk::DeviceGroupPresentInfoKHR & operator=( vk::DeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupPresentInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupPresentInfoKHR( rhs ) - {} + { + *this = rhs; + } DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupPresentInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31234,61 +29875,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupPresentInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupPresentInfoKHR; + const void* pNext = nullptr; + uint32_t swapchainCount; + const uint32_t* pDeviceMasks; + vk::DeviceGroupPresentModeFlagBitsKHR mode; }; static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGroupRenderPassBeginInfo - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0, - uint32_t deviceRenderAreaCount_ = 0, - const vk::Rect2D* pDeviceRenderAreas_ = nullptr ) VULKAN_HPP_NOEXCEPT - : deviceMask( deviceMask_ ) - , deviceRenderAreaCount( deviceRenderAreaCount_ ) - , pDeviceRenderAreas( pDeviceRenderAreas_ ) - {} - - DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo; - const void* pNext = nullptr; - uint32_t deviceMask; - uint32_t deviceRenderAreaCount; - const vk::Rect2D* pDeviceRenderAreas; - }; - static_assert( sizeof( DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupRenderPassBeginInfo : public layout::DeviceGroupRenderPassBeginInfo + struct DeviceGroupRenderPassBeginInfo { VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = 0, uint32_t deviceRenderAreaCount_ = 0, const vk::Rect2D* pDeviceRenderAreas_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupRenderPassBeginInfo( deviceMask_, deviceRenderAreaCount_, pDeviceRenderAreas_ ) + : deviceMask( deviceMask_ ) + , deviceRenderAreaCount( deviceRenderAreaCount_ ) + , pDeviceRenderAreas( pDeviceRenderAreas_ ) {} + vk::DeviceGroupRenderPassBeginInfo & operator=( vk::DeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupRenderPassBeginInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupRenderPassBeginInfo( rhs ) - {} + { + *this = rhs; + } DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupRenderPassBeginInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31340,56 +29960,17 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupRenderPassBeginInfo::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo; + const void* pNext = nullptr; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const vk::Rect2D* pDeviceRenderAreas; }; static_assert( sizeof( DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGroupSubmitInfo - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0, - const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr, - uint32_t commandBufferCount_ = 0, - const uint32_t* pCommandBufferDeviceMasks_ = nullptr, - uint32_t signalSemaphoreCount_ = 0, - const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ ) - , commandBufferCount( commandBufferCount_ ) - , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ ) - , signalSemaphoreCount( signalSemaphoreCount_ ) - , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ ) - {} - - DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupSubmitInfo; - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const uint32_t* pWaitSemaphoreDeviceIndices; - uint32_t commandBufferCount; - const uint32_t* pCommandBufferDeviceMasks; - uint32_t signalSemaphoreCount; - const uint32_t* pSignalSemaphoreDeviceIndices; - }; - static_assert( sizeof( DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupSubmitInfo : public layout::DeviceGroupSubmitInfo + struct DeviceGroupSubmitInfo { VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0, const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr, @@ -31397,16 +29978,28 @@ namespace VULKAN_HPP_NAMESPACE const uint32_t* pCommandBufferDeviceMasks_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupSubmitInfo( waitSemaphoreCount_, pWaitSemaphoreDeviceIndices_, commandBufferCount_, pCommandBufferDeviceMasks_, signalSemaphoreCount_, pSignalSemaphoreDeviceIndices_ ) + : waitSemaphoreCount( waitSemaphoreCount_ ) + , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ ) + , commandBufferCount( commandBufferCount_ ) + , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ ) + , signalSemaphoreCount( signalSemaphoreCount_ ) + , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ ) {} + vk::DeviceGroupSubmitInfo & operator=( vk::DeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupSubmitInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupSubmitInfo( rhs ) - {} + { + *this = rhs; + } DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupSubmitInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31479,53 +30072,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupSubmitInfo::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupSubmitInfo; + const void* pNext = nullptr; + uint32_t waitSemaphoreCount; + const uint32_t* pWaitSemaphoreDeviceIndices; + uint32_t commandBufferCount; + 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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceGroupSwapchainCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() ) VULKAN_HPP_NOEXCEPT - : modes( modes_ ) - {} - - DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR; - const void* pNext = nullptr; - vk::DeviceGroupPresentModeFlagsKHR modes; - }; - static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct DeviceGroupSwapchainCreateInfoKHR : public layout::DeviceGroupSwapchainCreateInfoKHR + struct DeviceGroupSwapchainCreateInfoKHR { VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupSwapchainCreateInfoKHR( modes_ ) + : modes( modes_ ) {} + vk::DeviceGroupSwapchainCreateInfoKHR & operator=( vk::DeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceGroupSwapchainCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceGroupSwapchainCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceGroupSwapchainCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31563,53 +30142,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceGroupSwapchainCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR; + const void* pNext = nullptr; + vk::DeviceGroupPresentModeFlagsKHR modes; }; static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceMemoryOverallocationCreateInfoAMD - { - protected: - VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( vk::MemoryOverallocationBehaviorAMD overallocationBehavior_ = vk::MemoryOverallocationBehaviorAMD::eDefault ) VULKAN_HPP_NOEXCEPT - : overallocationBehavior( overallocationBehavior_ ) - {} - - DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD; - const void* pNext = nullptr; - vk::MemoryOverallocationBehaviorAMD overallocationBehavior; - }; - static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "layout struct and wrapper have different size!" ); - } - - struct DeviceMemoryOverallocationCreateInfoAMD : public layout::DeviceMemoryOverallocationCreateInfoAMD + struct DeviceMemoryOverallocationCreateInfoAMD { VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( vk::MemoryOverallocationBehaviorAMD overallocationBehavior_ = vk::MemoryOverallocationBehaviorAMD::eDefault ) VULKAN_HPP_NOEXCEPT - : layout::DeviceMemoryOverallocationCreateInfoAMD( overallocationBehavior_ ) + : overallocationBehavior( overallocationBehavior_ ) {} + vk::DeviceMemoryOverallocationCreateInfoAMD & operator=( vk::DeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceMemoryOverallocationCreateInfoAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceMemoryOverallocationCreateInfoAMD( rhs ) - {} + { + *this = rhs; + } DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceMemoryOverallocationCreateInfoAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31647,53 +30207,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceMemoryOverallocationCreateInfoAMD::sType; + public: + const vk::StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD; + const void* pNext = nullptr; + vk::MemoryOverallocationBehaviorAMD overallocationBehavior; }; static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceQueueGlobalPriorityCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfoEXT( vk::QueueGlobalPriorityEXT globalPriority_ = vk::QueueGlobalPriorityEXT::eLow ) VULKAN_HPP_NOEXCEPT - : globalPriority( globalPriority_ ) - {} - - DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT; - const void* pNext = nullptr; - vk::QueueGlobalPriorityEXT globalPriority; - }; - static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DeviceQueueGlobalPriorityCreateInfoEXT : public layout::DeviceQueueGlobalPriorityCreateInfoEXT + struct DeviceQueueGlobalPriorityCreateInfoEXT { VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfoEXT( vk::QueueGlobalPriorityEXT globalPriority_ = vk::QueueGlobalPriorityEXT::eLow ) VULKAN_HPP_NOEXCEPT - : layout::DeviceQueueGlobalPriorityCreateInfoEXT( globalPriority_ ) + : globalPriority( globalPriority_ ) {} + vk::DeviceQueueGlobalPriorityCreateInfoEXT & operator=( vk::DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceQueueGlobalPriorityCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceQueueGlobalPriorityCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceQueueGlobalPriorityCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31731,61 +30272,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceQueueGlobalPriorityCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT; + const void* pNext = nullptr; + vk::QueueGlobalPriorityEXT globalPriority; }; static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DeviceQueueInfo2 - { - protected: - VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(), - uint32_t queueFamilyIndex_ = 0, - uint32_t queueIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , queueFamilyIndex( queueFamilyIndex_ ) - , queueIndex( queueIndex_ ) - {} - - DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDeviceQueueInfo2; - const void* pNext = nullptr; - vk::DeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueIndex; - }; - static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "layout struct and wrapper have different size!" ); - } - - struct DeviceQueueInfo2 : public layout::DeviceQueueInfo2 + struct DeviceQueueInfo2 { VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( vk::DeviceQueueCreateFlags flags_ = vk::DeviceQueueCreateFlags(), uint32_t queueFamilyIndex_ = 0, uint32_t queueIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DeviceQueueInfo2( flags_, queueFamilyIndex_, queueIndex_ ) + : flags( flags_ ) + , queueFamilyIndex( queueFamilyIndex_ ) + , queueIndex( queueIndex_ ) {} + vk::DeviceQueueInfo2 & operator=( vk::DeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DeviceQueueInfo2 ) - sizeof( vk::StructureType ) ); + return *this; + } + DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DeviceQueueInfo2( rhs ) - {} + { + *this = rhs; + } DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DeviceQueueInfo2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31837,8 +30355,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DeviceQueueInfo2::sType; + public: + const vk::StructureType sType = StructureType::eDeviceQueueInfo2; + const void* pNext = nullptr; + vk::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::value, "struct wrapper is not a standard layout!" ); @@ -31855,12 +30377,12 @@ namespace VULKAN_HPP_NAMESPACE DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -31912,47 +30434,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DisplayEventInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( vk::DisplayEventTypeEXT displayEvent_ = vk::DisplayEventTypeEXT::eFirstPixelOut ) VULKAN_HPP_NOEXCEPT - : displayEvent( displayEvent_ ) - {} - - DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayEventInfoEXT; - const void* pNext = nullptr; - vk::DisplayEventTypeEXT displayEvent; - }; - static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DisplayEventInfoEXT : public layout::DisplayEventInfoEXT + struct DisplayEventInfoEXT { VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( vk::DisplayEventTypeEXT displayEvent_ = vk::DisplayEventTypeEXT::eFirstPixelOut ) VULKAN_HPP_NOEXCEPT - : layout::DisplayEventInfoEXT( displayEvent_ ) + : displayEvent( displayEvent_ ) {} + vk::DisplayEventInfoEXT & operator=( vk::DisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayEventInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayEventInfoEXT( rhs ) - {} + { + *this = rhs; + } DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayEventInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -31990,8 +30491,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayEventInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDisplayEventInfoEXT; + const void* pNext = nullptr; + vk::DisplayEventTypeEXT displayEvent; }; static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -32006,12 +30509,12 @@ namespace VULKAN_HPP_NAMESPACE DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -32055,51 +30558,28 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DisplayModeCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( vk::DisplayModeCreateFlagsKHR flags_ = vk::DisplayModeCreateFlagsKHR(), - vk::DisplayModeParametersKHR parameters_ = vk::DisplayModeParametersKHR() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , parameters( parameters_ ) - {} - - DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayModeCreateInfoKHR; - const void* pNext = nullptr; - vk::DisplayModeCreateFlagsKHR flags; - vk::DisplayModeParametersKHR parameters; - }; - static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplayModeCreateInfoKHR : public layout::DisplayModeCreateInfoKHR + struct DisplayModeCreateInfoKHR { VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( vk::DisplayModeCreateFlagsKHR flags_ = vk::DisplayModeCreateFlagsKHR(), vk::DisplayModeParametersKHR parameters_ = vk::DisplayModeParametersKHR() ) VULKAN_HPP_NOEXCEPT - : layout::DisplayModeCreateInfoKHR( flags_, parameters_ ) + : flags( flags_ ) + , parameters( parameters_ ) {} + vk::DisplayModeCreateInfoKHR & operator=( vk::DisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayModeCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayModeCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayModeCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32144,25 +30624,31 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayModeCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplayModeCreateInfoKHR; + const void* pNext = nullptr; + vk::DisplayModeCreateFlagsKHR flags; + vk::DisplayModeParametersKHR parameters; }; static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct DisplayModePropertiesKHR { - DisplayModePropertiesKHR() VULKAN_HPP_NOEXCEPT + DisplayModePropertiesKHR( vk::DisplayModeKHR displayMode_ = vk::DisplayModeKHR(), + vk::DisplayModeParametersKHR parameters_ = vk::DisplayModeParametersKHR() ) VULKAN_HPP_NOEXCEPT + : displayMode( displayMode_ ) + , parameters( parameters_ ) {} DisplayModePropertiesKHR( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DisplayModePropertiesKHR& operator=( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -32194,46 +30680,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DisplayModeProperties2KHR { - struct DisplayModeProperties2KHR - { - protected: - DisplayModeProperties2KHR() VULKAN_HPP_NOEXCEPT - {} - - DisplayModeProperties2KHR( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayModeProperties2KHR& operator=( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayModeProperties2KHR; - void* pNext = nullptr; - vk::DisplayModePropertiesKHR displayModeProperties; - }; - static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplayModeProperties2KHR : public layout::DisplayModeProperties2KHR - { - DisplayModeProperties2KHR() VULKAN_HPP_NOEXCEPT - : layout::DisplayModeProperties2KHR() + DisplayModeProperties2KHR( vk::DisplayModePropertiesKHR displayModeProperties_ = vk::DisplayModePropertiesKHR() ) VULKAN_HPP_NOEXCEPT + : displayModeProperties( displayModeProperties_ ) {} + vk::DisplayModeProperties2KHR & operator=( vk::DisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayModeProperties2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayModeProperties2KHR( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayModeProperties2KHR( rhs ) - {} + { + *this = rhs; + } DisplayModeProperties2KHR& operator=( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayModeProperties2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32259,52 +30725,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayModeProperties2KHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplayModeProperties2KHR; + void* pNext = nullptr; + vk::DisplayModePropertiesKHR displayModeProperties; }; static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DisplayNativeHdrSurfaceCapabilitiesAMD { - struct DisplayNativeHdrSurfaceCapabilitiesAMD - { - protected: - DisplayNativeHdrSurfaceCapabilitiesAMD() VULKAN_HPP_NOEXCEPT - {} - - DisplayNativeHdrSurfaceCapabilitiesAMD( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayNativeHdrSurfaceCapabilitiesAMD& operator=( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD; - void* pNext = nullptr; - vk::Bool32 localDimmingSupport; - }; - static_assert( sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), "layout struct and wrapper have different size!" ); - } - - struct DisplayNativeHdrSurfaceCapabilitiesAMD : public layout::DisplayNativeHdrSurfaceCapabilitiesAMD - { - DisplayNativeHdrSurfaceCapabilitiesAMD() VULKAN_HPP_NOEXCEPT - : layout::DisplayNativeHdrSurfaceCapabilitiesAMD() + DisplayNativeHdrSurfaceCapabilitiesAMD( vk::Bool32 localDimmingSupport_ = 0 ) VULKAN_HPP_NOEXCEPT + : localDimmingSupport( localDimmingSupport_ ) {} + vk::DisplayNativeHdrSurfaceCapabilitiesAMD & operator=( vk::DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayNativeHdrSurfaceCapabilitiesAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayNativeHdrSurfaceCapabilitiesAMD( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayNativeHdrSurfaceCapabilitiesAMD( rhs ) - {} + { + *this = rhs; + } DisplayNativeHdrSurfaceCapabilitiesAMD& operator=( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayNativeHdrSurfaceCapabilitiesAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32330,25 +30778,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayNativeHdrSurfaceCapabilitiesAMD::sType; + public: + const vk::StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD; + void* pNext = nullptr; + vk::Bool32 localDimmingSupport; }; static_assert( sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct DisplayPlaneCapabilitiesKHR { - DisplayPlaneCapabilitiesKHR() VULKAN_HPP_NOEXCEPT + DisplayPlaneCapabilitiesKHR( vk::DisplayPlaneAlphaFlagsKHR supportedAlpha_ = vk::DisplayPlaneAlphaFlagsKHR(), + vk::Offset2D minSrcPosition_ = vk::Offset2D(), + vk::Offset2D maxSrcPosition_ = vk::Offset2D(), + vk::Extent2D minSrcExtent_ = vk::Extent2D(), + vk::Extent2D maxSrcExtent_ = vk::Extent2D(), + vk::Offset2D minDstPosition_ = vk::Offset2D(), + vk::Offset2D maxDstPosition_ = vk::Offset2D(), + vk::Extent2D minDstExtent_ = vk::Extent2D(), + vk::Extent2D maxDstExtent_ = vk::Extent2D() ) VULKAN_HPP_NOEXCEPT + : supportedAlpha( supportedAlpha_ ) + , minSrcPosition( minSrcPosition_ ) + , maxSrcPosition( maxSrcPosition_ ) + , minSrcExtent( minSrcExtent_ ) + , maxSrcExtent( maxSrcExtent_ ) + , minDstPosition( minDstPosition_ ) + , maxDstPosition( maxDstPosition_ ) + , minDstExtent( minDstExtent_ ) + , maxDstExtent( maxDstExtent_ ) {} DisplayPlaneCapabilitiesKHR( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DisplayPlaneCapabilitiesKHR& operator=( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -32394,46 +30861,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DisplayPlaneCapabilities2KHR { - struct DisplayPlaneCapabilities2KHR - { - protected: - DisplayPlaneCapabilities2KHR() VULKAN_HPP_NOEXCEPT - {} - - DisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayPlaneCapabilities2KHR& operator=( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR; - void* pNext = nullptr; - vk::DisplayPlaneCapabilitiesKHR capabilities; - }; - static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplayPlaneCapabilities2KHR : public layout::DisplayPlaneCapabilities2KHR - { - DisplayPlaneCapabilities2KHR() VULKAN_HPP_NOEXCEPT - : layout::DisplayPlaneCapabilities2KHR() + DisplayPlaneCapabilities2KHR( vk::DisplayPlaneCapabilitiesKHR capabilities_ = vk::DisplayPlaneCapabilitiesKHR() ) VULKAN_HPP_NOEXCEPT + : capabilities( capabilities_ ) {} + vk::DisplayPlaneCapabilities2KHR & operator=( vk::DisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPlaneCapabilities2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPlaneCapabilities2KHR( rhs ) - {} + { + *this = rhs; + } DisplayPlaneCapabilities2KHR& operator=( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayPlaneCapabilities2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32459,57 +30906,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayPlaneCapabilities2KHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR; + void* pNext = nullptr; + vk::DisplayPlaneCapabilitiesKHR capabilities; }; static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DisplayPlaneInfo2KHR - { - protected: - VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( vk::DisplayModeKHR mode_ = vk::DisplayModeKHR(), - uint32_t planeIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : mode( mode_ ) - , planeIndex( planeIndex_ ) - {} - - DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayPlaneInfo2KHR; - const void* pNext = nullptr; - vk::DisplayModeKHR mode; - uint32_t planeIndex; - }; - static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplayPlaneInfo2KHR : public layout::DisplayPlaneInfo2KHR + struct DisplayPlaneInfo2KHR { VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( vk::DisplayModeKHR mode_ = vk::DisplayModeKHR(), uint32_t planeIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPlaneInfo2KHR( mode_, planeIndex_ ) + : mode( mode_ ) + , planeIndex( planeIndex_ ) {} + vk::DisplayPlaneInfo2KHR & operator=( vk::DisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPlaneInfo2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPlaneInfo2KHR( rhs ) - {} + { + *this = rhs; + } DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayPlaneInfo2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32554,25 +30980,31 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayPlaneInfo2KHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplayPlaneInfo2KHR; + const void* pNext = nullptr; + vk::DisplayModeKHR mode; + uint32_t planeIndex; }; static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct DisplayPlanePropertiesKHR { - DisplayPlanePropertiesKHR() VULKAN_HPP_NOEXCEPT + DisplayPlanePropertiesKHR( vk::DisplayKHR currentDisplay_ = vk::DisplayKHR(), + uint32_t currentStackIndex_ = 0 ) VULKAN_HPP_NOEXCEPT + : currentDisplay( currentDisplay_ ) + , currentStackIndex( currentStackIndex_ ) {} DisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DisplayPlanePropertiesKHR& operator=( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -32604,46 +31036,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DisplayPlaneProperties2KHR { - struct DisplayPlaneProperties2KHR - { - protected: - DisplayPlaneProperties2KHR() VULKAN_HPP_NOEXCEPT - {} - - DisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayPlaneProperties2KHR& operator=( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayPlaneProperties2KHR; - void* pNext = nullptr; - vk::DisplayPlanePropertiesKHR displayPlaneProperties; - }; - static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplayPlaneProperties2KHR : public layout::DisplayPlaneProperties2KHR - { - DisplayPlaneProperties2KHR() VULKAN_HPP_NOEXCEPT - : layout::DisplayPlaneProperties2KHR() + DisplayPlaneProperties2KHR( vk::DisplayPlanePropertiesKHR displayPlaneProperties_ = vk::DisplayPlanePropertiesKHR() ) VULKAN_HPP_NOEXCEPT + : displayPlaneProperties( displayPlaneProperties_ ) {} + vk::DisplayPlaneProperties2KHR & operator=( vk::DisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPlaneProperties2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPlaneProperties2KHR( rhs ) - {} + { + *this = rhs; + } DisplayPlaneProperties2KHR& operator=( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayPlaneProperties2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32669,53 +31081,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayPlaneProperties2KHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplayPlaneProperties2KHR; + void* pNext = nullptr; + vk::DisplayPlanePropertiesKHR displayPlaneProperties; }; static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DisplayPowerInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( vk::DisplayPowerStateEXT powerState_ = vk::DisplayPowerStateEXT::eOff ) VULKAN_HPP_NOEXCEPT - : powerState( powerState_ ) - {} - - DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayPowerInfoEXT; - const void* pNext = nullptr; - vk::DisplayPowerStateEXT powerState; - }; - static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct DisplayPowerInfoEXT : public layout::DisplayPowerInfoEXT + struct DisplayPowerInfoEXT { VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( vk::DisplayPowerStateEXT powerState_ = vk::DisplayPowerStateEXT::eOff ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPowerInfoEXT( powerState_ ) + : powerState( powerState_ ) {} + vk::DisplayPowerInfoEXT & operator=( vk::DisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPowerInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPowerInfoEXT( rhs ) - {} + { + *this = rhs; + } DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayPowerInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32753,61 +31146,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayPowerInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eDisplayPowerInfoEXT; + const void* pNext = nullptr; + vk::DisplayPowerStateEXT powerState; }; static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DisplayPresentInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( vk::Rect2D srcRect_ = vk::Rect2D(), - vk::Rect2D dstRect_ = vk::Rect2D(), - vk::Bool32 persistent_ = 0 ) VULKAN_HPP_NOEXCEPT - : srcRect( srcRect_ ) - , dstRect( dstRect_ ) - , persistent( persistent_ ) - {} - - DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayPresentInfoKHR; - const void* pNext = nullptr; - vk::Rect2D srcRect; - vk::Rect2D dstRect; - vk::Bool32 persistent; - }; - static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplayPresentInfoKHR : public layout::DisplayPresentInfoKHR + struct DisplayPresentInfoKHR { VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( vk::Rect2D srcRect_ = vk::Rect2D(), vk::Rect2D dstRect_ = vk::Rect2D(), vk::Bool32 persistent_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPresentInfoKHR( srcRect_, dstRect_, persistent_ ) + : srcRect( srcRect_ ) + , dstRect( dstRect_ ) + , persistent( persistent_ ) {} + vk::DisplayPresentInfoKHR & operator=( vk::DisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayPresentInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayPresentInfoKHR( rhs ) - {} + { + *this = rhs; + } DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayPresentInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32859,25 +31229,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayPresentInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplayPresentInfoKHR; + const void* pNext = nullptr; + vk::Rect2D srcRect; + vk::Rect2D dstRect; + vk::Bool32 persistent; }; static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct DisplayPropertiesKHR { - DisplayPropertiesKHR() VULKAN_HPP_NOEXCEPT + DisplayPropertiesKHR( vk::DisplayKHR display_ = vk::DisplayKHR(), + const char* displayName_ = nullptr, + vk::Extent2D physicalDimensions_ = vk::Extent2D(), + vk::Extent2D physicalResolution_ = vk::Extent2D(), + vk::SurfaceTransformFlagsKHR supportedTransforms_ = vk::SurfaceTransformFlagsKHR(), + vk::Bool32 planeReorderPossible_ = 0, + vk::Bool32 persistentContent_ = 0 ) VULKAN_HPP_NOEXCEPT + : display( display_ ) + , displayName( displayName_ ) + , physicalDimensions( physicalDimensions_ ) + , physicalResolution( physicalResolution_ ) + , supportedTransforms( supportedTransforms_ ) + , planeReorderPossible( planeReorderPossible_ ) + , persistentContent( persistentContent_ ) {} DisplayPropertiesKHR( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DisplayPropertiesKHR& operator=( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -32919,46 +31306,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DisplayProperties2KHR { - struct DisplayProperties2KHR - { - protected: - DisplayProperties2KHR() VULKAN_HPP_NOEXCEPT - {} - - DisplayProperties2KHR( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplayProperties2KHR& operator=( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplayProperties2KHR; - void* pNext = nullptr; - vk::DisplayPropertiesKHR displayProperties; - }; - static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplayProperties2KHR : public layout::DisplayProperties2KHR - { - DisplayProperties2KHR() VULKAN_HPP_NOEXCEPT - : layout::DisplayProperties2KHR() + DisplayProperties2KHR( vk::DisplayPropertiesKHR displayProperties_ = vk::DisplayPropertiesKHR() ) VULKAN_HPP_NOEXCEPT + : displayProperties( displayProperties_ ) {} + vk::DisplayProperties2KHR & operator=( vk::DisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplayProperties2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplayProperties2KHR( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplayProperties2KHR( rhs ) - {} + { + *this = rhs; + } DisplayProperties2KHR& operator=( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplayProperties2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -32984,62 +31351,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplayProperties2KHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplayProperties2KHR; + void* pNext = nullptr; + vk::DisplayPropertiesKHR displayProperties; }; static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct DisplaySurfaceCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( vk::DisplaySurfaceCreateFlagsKHR flags_ = vk::DisplaySurfaceCreateFlagsKHR(), - vk::DisplayModeKHR displayMode_ = vk::DisplayModeKHR(), - uint32_t planeIndex_ = 0, - uint32_t planeStackIndex_ = 0, - vk::SurfaceTransformFlagBitsKHR transform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity, - float globalAlpha_ = 0, - vk::DisplayPlaneAlphaFlagBitsKHR alphaMode_ = vk::DisplayPlaneAlphaFlagBitsKHR::eOpaque, - vk::Extent2D imageExtent_ = vk::Extent2D() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , displayMode( displayMode_ ) - , planeIndex( planeIndex_ ) - , planeStackIndex( planeStackIndex_ ) - , transform( transform_ ) - , globalAlpha( globalAlpha_ ) - , alphaMode( alphaMode_ ) - , imageExtent( imageExtent_ ) - {} - - DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR; - const void* pNext = nullptr; - vk::DisplaySurfaceCreateFlagsKHR flags; - vk::DisplayModeKHR displayMode; - uint32_t planeIndex; - uint32_t planeStackIndex; - vk::SurfaceTransformFlagBitsKHR transform; - float globalAlpha; - vk::DisplayPlaneAlphaFlagBitsKHR alphaMode; - vk::Extent2D imageExtent; - }; - static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct DisplaySurfaceCreateInfoKHR : public layout::DisplaySurfaceCreateInfoKHR + struct DisplaySurfaceCreateInfoKHR { VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( vk::DisplaySurfaceCreateFlagsKHR flags_ = vk::DisplaySurfaceCreateFlagsKHR(), vk::DisplayModeKHR displayMode_ = vk::DisplayModeKHR(), @@ -33049,16 +31369,30 @@ namespace VULKAN_HPP_NAMESPACE float globalAlpha_ = 0, vk::DisplayPlaneAlphaFlagBitsKHR alphaMode_ = vk::DisplayPlaneAlphaFlagBitsKHR::eOpaque, vk::Extent2D imageExtent_ = vk::Extent2D() ) VULKAN_HPP_NOEXCEPT - : layout::DisplaySurfaceCreateInfoKHR( flags_, displayMode_, planeIndex_, planeStackIndex_, transform_, globalAlpha_, alphaMode_, imageExtent_ ) + : flags( flags_ ) + , displayMode( displayMode_ ) + , planeIndex( planeIndex_ ) + , planeStackIndex( planeStackIndex_ ) + , transform( transform_ ) + , globalAlpha( globalAlpha_ ) + , alphaMode( alphaMode_ ) + , imageExtent( imageExtent_ ) {} + vk::DisplaySurfaceCreateInfoKHR & operator=( vk::DisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DisplaySurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DisplaySurfaceCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DisplaySurfaceCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33145,8 +31479,17 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DisplaySurfaceCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR; + const void* pNext = nullptr; + vk::DisplaySurfaceCreateFlagsKHR flags; + vk::DisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + vk::SurfaceTransformFlagBitsKHR transform; + float globalAlpha; + vk::DisplayPlaneAlphaFlagBitsKHR alphaMode; + vk::Extent2D imageExtent; }; static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -33167,12 +31510,12 @@ namespace VULKAN_HPP_NAMESPACE DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -33254,12 +31597,12 @@ namespace VULKAN_HPP_NAMESPACE DrawIndirectCommand( VkDrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -33329,12 +31672,12 @@ namespace VULKAN_HPP_NAMESPACE DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DrawMeshTasksIndirectCommandNV& operator=( VkDrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -33380,17 +31723,22 @@ namespace VULKAN_HPP_NAMESPACE struct DrmFormatModifierPropertiesEXT { - DrmFormatModifierPropertiesEXT() VULKAN_HPP_NOEXCEPT + DrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = 0, + uint32_t drmFormatModifierPlaneCount_ = 0, + vk::FormatFeatureFlags drmFormatModifierTilingFeatures_ = vk::FormatFeatureFlags() ) VULKAN_HPP_NOEXCEPT + : drmFormatModifier( drmFormatModifier_ ) + , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ ) + , drmFormatModifierTilingFeatures( drmFormatModifierTilingFeatures_ ) {} DrmFormatModifierPropertiesEXT( VkDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } DrmFormatModifierPropertiesEXT& operator=( VkDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -33424,47 +31772,28 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( DrmFormatModifierPropertiesEXT ) == sizeof( VkDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct DrmFormatModifierPropertiesListEXT { - struct DrmFormatModifierPropertiesListEXT - { - protected: - DrmFormatModifierPropertiesListEXT() VULKAN_HPP_NOEXCEPT - {} - - DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - DrmFormatModifierPropertiesListEXT& operator=( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT; - void* pNext = nullptr; - uint32_t drmFormatModifierCount; - vk::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; - }; - static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "layout struct and wrapper have different size!" ); - } - - struct DrmFormatModifierPropertiesListEXT : public layout::DrmFormatModifierPropertiesListEXT - { - DrmFormatModifierPropertiesListEXT() VULKAN_HPP_NOEXCEPT - : layout::DrmFormatModifierPropertiesListEXT() + DrmFormatModifierPropertiesListEXT( uint32_t drmFormatModifierCount_ = 0, + vk::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties_ = nullptr ) VULKAN_HPP_NOEXCEPT + : drmFormatModifierCount( drmFormatModifierCount_ ) + , pDrmFormatModifierProperties( pDrmFormatModifierProperties_ ) {} + vk::DrmFormatModifierPropertiesListEXT & operator=( vk::DrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::DrmFormatModifierPropertiesListEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::DrmFormatModifierPropertiesListEXT( rhs ) - {} + { + *this = rhs; + } DrmFormatModifierPropertiesListEXT& operator=( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::DrmFormatModifierPropertiesListEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33491,53 +31820,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::DrmFormatModifierPropertiesListEXT::sType; + public: + const vk::StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT; + void* pNext = nullptr; + uint32_t drmFormatModifierCount; + vk::DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; }; static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct EventCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR EventCreateInfo( vk::EventCreateFlags flags_ = vk::EventCreateFlags() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - {} - - EventCreateInfo( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - EventCreateInfo& operator=( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eEventCreateInfo; - const void* pNext = nullptr; - vk::EventCreateFlags flags; - }; - static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct EventCreateInfo : public layout::EventCreateInfo + struct EventCreateInfo { VULKAN_HPP_CONSTEXPR EventCreateInfo( vk::EventCreateFlags flags_ = vk::EventCreateFlags() ) VULKAN_HPP_NOEXCEPT - : layout::EventCreateInfo( flags_ ) + : flags( flags_ ) {} + vk::EventCreateInfo & operator=( vk::EventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::EventCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + EventCreateInfo( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::EventCreateInfo( rhs ) - {} + { + *this = rhs; + } EventCreateInfo& operator=( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::EventCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33575,53 +31886,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::EventCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eEventCreateInfo; + const void* pNext = nullptr; + vk::EventCreateFlags flags; }; static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ExportFenceCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( vk::ExternalFenceHandleTypeFlags handleTypes_ = vk::ExternalFenceHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : handleTypes( handleTypes_ ) - {} - - ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportFenceCreateInfo; - const void* pNext = nullptr; - vk::ExternalFenceHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ExportFenceCreateInfo : public layout::ExportFenceCreateInfo + struct ExportFenceCreateInfo { VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( vk::ExternalFenceHandleTypeFlags handleTypes_ = vk::ExternalFenceHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : layout::ExportFenceCreateInfo( handleTypes_ ) + : handleTypes( handleTypes_ ) {} + vk::ExportFenceCreateInfo & operator=( vk::ExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportFenceCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportFenceCreateInfo( rhs ) - {} + { + *this = rhs; + } ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportFenceCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33659,63 +31951,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportFenceCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eExportFenceCreateInfo; + const void* pNext = nullptr; + vk::ExternalFenceHandleTypeFlags handleTypes; }; static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ExportFenceWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, - DWORD dwAccess_ = 0, - LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - , name( name_ ) - {} - - ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR; - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; - }; - static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ExportFenceWin32HandleInfoKHR : public layout::ExportFenceWin32HandleInfoKHR + struct ExportFenceWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ExportFenceWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ ) + : pAttributes( pAttributes_ ) + , dwAccess( dwAccess_ ) + , name( name_ ) {} + vk::ExportFenceWin32HandleInfoKHR & operator=( vk::ExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportFenceWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportFenceWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportFenceWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33767,54 +32036,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportFenceWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR; + const void* pNext = nullptr; + 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::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct ExportMemoryAllocateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : handleTypes( handleTypes_ ) - {} - - ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportMemoryAllocateInfo; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ExportMemoryAllocateInfo : public layout::ExportMemoryAllocateInfo + struct ExportMemoryAllocateInfo { VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryAllocateInfo( handleTypes_ ) + : handleTypes( handleTypes_ ) {} + vk::ExportMemoryAllocateInfo & operator=( vk::ExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportMemoryAllocateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryAllocateInfo( rhs ) - {} + { + *this = rhs; + } ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportMemoryAllocateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33852,53 +32104,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportMemoryAllocateInfo::sType; + public: + const vk::StructureType sType = StructureType::eExportMemoryAllocateInfo; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlags handleTypes; }; static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ExportMemoryAllocateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT - : handleTypes( handleTypes_ ) - {} - - ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportMemoryAllocateInfoNV; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlagsNV handleTypes; - }; - static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct ExportMemoryAllocateInfoNV : public layout::ExportMemoryAllocateInfoNV + struct ExportMemoryAllocateInfoNV { VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryAllocateInfoNV( handleTypes_ ) + : handleTypes( handleTypes_ ) {} + vk::ExportMemoryAllocateInfoNV & operator=( vk::ExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportMemoryAllocateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryAllocateInfoNV( rhs ) - {} + { + *this = rhs; + } ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportMemoryAllocateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -33936,63 +32169,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportMemoryAllocateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eExportMemoryAllocateInfoNV; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlagsNV handleTypes; }; static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ExportMemoryWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, - DWORD dwAccess_ = 0, - LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - , name( name_ ) - {} - - ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR; - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; - }; - static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ExportMemoryWin32HandleInfoKHR : public layout::ExportMemoryWin32HandleInfoKHR + struct ExportMemoryWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ ) + : pAttributes( pAttributes_ ) + , dwAccess( dwAccess_ ) + , name( name_ ) {} + vk::ExportMemoryWin32HandleInfoKHR & operator=( vk::ExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportMemoryWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportMemoryWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34044,8 +32254,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportMemoryWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR; + const void* pNext = nullptr; + 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::value, "struct wrapper is not a standard layout!" ); @@ -34053,51 +32267,28 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ExportMemoryWin32HandleInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, - DWORD dwAccess_ = 0 ) VULKAN_HPP_NOEXCEPT - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - {} - - ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV; - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - }; - static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct ExportMemoryWin32HandleInfoNV : public layout::ExportMemoryWin32HandleInfoNV + struct ExportMemoryWin32HandleInfoNV { VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryWin32HandleInfoNV( pAttributes_, dwAccess_ ) + : pAttributes( pAttributes_ ) + , dwAccess( dwAccess_ ) {} + vk::ExportMemoryWin32HandleInfoNV & operator=( vk::ExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportMemoryWin32HandleInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportMemoryWin32HandleInfoNV( rhs ) - {} + { + *this = rhs; + } ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportMemoryWin32HandleInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34142,54 +32333,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportMemoryWin32HandleInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV; + const void* pNext = nullptr; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; }; static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct ExportSemaphoreCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( vk::ExternalSemaphoreHandleTypeFlags handleTypes_ = vk::ExternalSemaphoreHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : handleTypes( handleTypes_ ) - {} - - ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportSemaphoreCreateInfo; - const void* pNext = nullptr; - vk::ExternalSemaphoreHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ExportSemaphoreCreateInfo : public layout::ExportSemaphoreCreateInfo + struct ExportSemaphoreCreateInfo { VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( vk::ExternalSemaphoreHandleTypeFlags handleTypes_ = vk::ExternalSemaphoreHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : layout::ExportSemaphoreCreateInfo( handleTypes_ ) + : handleTypes( handleTypes_ ) {} + vk::ExportSemaphoreCreateInfo & operator=( vk::ExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportSemaphoreCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportSemaphoreCreateInfo( rhs ) - {} + { + *this = rhs; + } ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportSemaphoreCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34227,63 +32400,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportSemaphoreCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eExportSemaphoreCreateInfo; + const void* pNext = nullptr; + vk::ExternalSemaphoreHandleTypeFlags handleTypes; }; static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ExportSemaphoreWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, - DWORD dwAccess_ = 0, - LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pAttributes( pAttributes_ ) - , dwAccess( dwAccess_ ) - , name( name_ ) - {} - - ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR; - const void* pNext = nullptr; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; - }; - static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ExportSemaphoreWin32HandleInfoKHR : public layout::ExportSemaphoreWin32HandleInfoKHR + struct ExportSemaphoreWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ExportSemaphoreWin32HandleInfoKHR( pAttributes_, dwAccess_, name_ ) + : pAttributes( pAttributes_ ) + , dwAccess( dwAccess_ ) + , name( name_ ) {} + vk::ExportSemaphoreWin32HandleInfoKHR & operator=( vk::ExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExportSemaphoreWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExportSemaphoreWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExportSemaphoreWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34335,8 +32485,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExportSemaphoreWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR; + const void* pNext = nullptr; + 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::value, "struct wrapper is not a standard layout!" ); @@ -34344,17 +32498,22 @@ namespace VULKAN_HPP_NAMESPACE struct ExtensionProperties { - ExtensionProperties() VULKAN_HPP_NOEXCEPT - {} + ExtensionProperties( std::array const& extensionName_ = { { 0 } }, + uint32_t specVersion_ = 0 ) VULKAN_HPP_NOEXCEPT + : extensionName{} + , specVersion( specVersion_ ) + { + vk::ConstExpressionArrayCopy::copy( extensionName, extensionName_ ); + } ExtensionProperties( VkExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ExtensionProperties& operator=( VkExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -34388,17 +32547,22 @@ namespace VULKAN_HPP_NAMESPACE struct ExternalMemoryProperties { - ExternalMemoryProperties() VULKAN_HPP_NOEXCEPT + ExternalMemoryProperties( vk::ExternalMemoryFeatureFlags externalMemoryFeatures_ = vk::ExternalMemoryFeatureFlags(), + vk::ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes_ = vk::ExternalMemoryHandleTypeFlags(), + vk::ExternalMemoryHandleTypeFlags compatibleHandleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT + : externalMemoryFeatures( externalMemoryFeatures_ ) + , exportFromImportedHandleTypes( exportFromImportedHandleTypes_ ) + , compatibleHandleTypes( compatibleHandleTypes_ ) {} ExternalMemoryProperties( VkExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ExternalMemoryProperties& operator=( VkExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -34432,46 +32596,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct ExternalBufferProperties { - struct ExternalBufferProperties - { - protected: - ExternalBufferProperties() VULKAN_HPP_NOEXCEPT - {} - - ExternalBufferProperties( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalBufferProperties& operator=( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalBufferProperties; - void* pNext = nullptr; - vk::ExternalMemoryProperties externalMemoryProperties; - }; - static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "layout struct and wrapper have different size!" ); - } - - struct ExternalBufferProperties : public layout::ExternalBufferProperties - { - ExternalBufferProperties() VULKAN_HPP_NOEXCEPT - : layout::ExternalBufferProperties() + ExternalBufferProperties( vk::ExternalMemoryProperties externalMemoryProperties_ = vk::ExternalMemoryProperties() ) VULKAN_HPP_NOEXCEPT + : externalMemoryProperties( externalMemoryProperties_ ) {} + vk::ExternalBufferProperties & operator=( vk::ExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalBufferProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalBufferProperties( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalBufferProperties( rhs ) - {} + { + *this = rhs; + } ExternalBufferProperties& operator=( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalBufferProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34497,54 +32641,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalBufferProperties::sType; + public: + const vk::StructureType sType = StructureType::eExternalBufferProperties; + void* pNext = nullptr; + vk::ExternalMemoryProperties externalMemoryProperties; }; static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct ExternalFenceProperties { - struct ExternalFenceProperties - { - protected: - ExternalFenceProperties() VULKAN_HPP_NOEXCEPT - {} - - ExternalFenceProperties( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalFenceProperties& operator=( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalFenceProperties; - void* pNext = nullptr; - vk::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes; - vk::ExternalFenceHandleTypeFlags compatibleHandleTypes; - vk::ExternalFenceFeatureFlags externalFenceFeatures; - }; - static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "layout struct and wrapper have different size!" ); - } - - struct ExternalFenceProperties : public layout::ExternalFenceProperties - { - ExternalFenceProperties() VULKAN_HPP_NOEXCEPT - : layout::ExternalFenceProperties() + ExternalFenceProperties( vk::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes_ = vk::ExternalFenceHandleTypeFlags(), + vk::ExternalFenceHandleTypeFlags compatibleHandleTypes_ = vk::ExternalFenceHandleTypeFlags(), + vk::ExternalFenceFeatureFlags externalFenceFeatures_ = vk::ExternalFenceFeatureFlags() ) VULKAN_HPP_NOEXCEPT + : exportFromImportedHandleTypes( exportFromImportedHandleTypes_ ) + , compatibleHandleTypes( compatibleHandleTypes_ ) + , externalFenceFeatures( externalFenceFeatures_ ) {} + vk::ExternalFenceProperties & operator=( vk::ExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalFenceProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalFenceProperties( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalFenceProperties( rhs ) - {} + { + *this = rhs; + } ExternalFenceProperties& operator=( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalFenceProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34572,55 +32700,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalFenceProperties::sType; + public: + const vk::StructureType sType = StructureType::eExternalFenceProperties; + void* pNext = nullptr; + vk::ExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + vk::ExternalFenceHandleTypeFlags compatibleHandleTypes; + vk::ExternalFenceFeatureFlags externalFenceFeatures; }; static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_ANDROID_KHR - namespace layout - { - struct ExternalFormatANDROID - { - protected: - VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( uint64_t externalFormat_ = 0 ) VULKAN_HPP_NOEXCEPT - : externalFormat( externalFormat_ ) - {} - - ExternalFormatANDROID( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalFormatANDROID; - void* pNext = nullptr; - uint64_t externalFormat; - }; - static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "layout struct and wrapper have different size!" ); - } - - struct ExternalFormatANDROID : public layout::ExternalFormatANDROID + struct ExternalFormatANDROID { VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( uint64_t externalFormat_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ExternalFormatANDROID( externalFormat_ ) + : externalFormat( externalFormat_ ) {} + vk::ExternalFormatANDROID & operator=( vk::ExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalFormatANDROID ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalFormatANDROID( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalFormatANDROID( rhs ) - {} + { + *this = rhs; + } ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalFormatANDROID::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34658,53 +32769,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalFormatANDROID::sType; + public: + const vk::StructureType sType = StructureType::eExternalFormatANDROID; + void* pNext = nullptr; + uint64_t externalFormat; }; static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - namespace layout + struct ExternalImageFormatProperties { - struct ExternalImageFormatProperties - { - protected: - ExternalImageFormatProperties() VULKAN_HPP_NOEXCEPT - {} - - ExternalImageFormatProperties( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalImageFormatProperties& operator=( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalImageFormatProperties; - void* pNext = nullptr; - vk::ExternalMemoryProperties externalMemoryProperties; - }; - static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "layout struct and wrapper have different size!" ); - } - - struct ExternalImageFormatProperties : public layout::ExternalImageFormatProperties - { - ExternalImageFormatProperties() VULKAN_HPP_NOEXCEPT - : layout::ExternalImageFormatProperties() + ExternalImageFormatProperties( vk::ExternalMemoryProperties externalMemoryProperties_ = vk::ExternalMemoryProperties() ) VULKAN_HPP_NOEXCEPT + : externalMemoryProperties( externalMemoryProperties_ ) {} + vk::ExternalImageFormatProperties & operator=( vk::ExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalImageFormatProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalImageFormatProperties( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalImageFormatProperties( rhs ) - {} + { + *this = rhs; + } ExternalImageFormatProperties& operator=( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalImageFormatProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34730,25 +32823,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalImageFormatProperties::sType; + public: + const vk::StructureType sType = StructureType::eExternalImageFormatProperties; + void* pNext = nullptr; + vk::ExternalMemoryProperties externalMemoryProperties; }; static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct ImageFormatProperties { - ImageFormatProperties() VULKAN_HPP_NOEXCEPT + ImageFormatProperties( vk::Extent3D maxExtent_ = vk::Extent3D(), + uint32_t maxMipLevels_ = 0, + uint32_t maxArrayLayers_ = 0, + vk::SampleCountFlags sampleCounts_ = vk::SampleCountFlags(), + vk::DeviceSize maxResourceSize_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxExtent( maxExtent_ ) + , maxMipLevels( maxMipLevels_ ) + , maxArrayLayers( maxArrayLayers_ ) + , sampleCounts( sampleCounts_ ) + , maxResourceSize( maxResourceSize_ ) {} ImageFormatProperties( VkImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ImageFormatProperties& operator=( VkImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -34788,17 +32892,24 @@ namespace VULKAN_HPP_NAMESPACE struct ExternalImageFormatPropertiesNV { - ExternalImageFormatPropertiesNV() VULKAN_HPP_NOEXCEPT + ExternalImageFormatPropertiesNV( vk::ImageFormatProperties imageFormatProperties_ = vk::ImageFormatProperties(), + vk::ExternalMemoryFeatureFlagsNV externalMemoryFeatures_ = vk::ExternalMemoryFeatureFlagsNV(), + vk::ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV(), + vk::ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT + : imageFormatProperties( imageFormatProperties_ ) + , externalMemoryFeatures( externalMemoryFeatures_ ) + , exportFromImportedHandleTypes( exportFromImportedHandleTypes_ ) + , compatibleHandleTypes( compatibleHandleTypes_ ) {} ExternalImageFormatPropertiesNV( VkExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ExternalImageFormatPropertiesNV& operator=( VkExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -34834,47 +32945,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ExternalMemoryBufferCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : handleTypes( handleTypes_ ) - {} - - ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalMemoryBufferCreateInfo; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ExternalMemoryBufferCreateInfo : public layout::ExternalMemoryBufferCreateInfo + struct ExternalMemoryBufferCreateInfo { VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : layout::ExternalMemoryBufferCreateInfo( handleTypes_ ) + : handleTypes( handleTypes_ ) {} + vk::ExternalMemoryBufferCreateInfo & operator=( vk::ExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalMemoryBufferCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalMemoryBufferCreateInfo( rhs ) - {} + { + *this = rhs; + } ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalMemoryBufferCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34912,53 +33002,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalMemoryBufferCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eExternalMemoryBufferCreateInfo; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlags handleTypes; }; static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ExternalMemoryImageCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : handleTypes( handleTypes_ ) - {} - - ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalMemoryImageCreateInfo; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlags handleTypes; - }; - static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ExternalMemoryImageCreateInfo : public layout::ExternalMemoryImageCreateInfo + struct ExternalMemoryImageCreateInfo { VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( vk::ExternalMemoryHandleTypeFlags handleTypes_ = vk::ExternalMemoryHandleTypeFlags() ) VULKAN_HPP_NOEXCEPT - : layout::ExternalMemoryImageCreateInfo( handleTypes_ ) + : handleTypes( handleTypes_ ) {} + vk::ExternalMemoryImageCreateInfo & operator=( vk::ExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalMemoryImageCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalMemoryImageCreateInfo( rhs ) - {} + { + *this = rhs; + } ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalMemoryImageCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -34996,53 +33067,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalMemoryImageCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eExternalMemoryImageCreateInfo; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlags handleTypes; }; static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ExternalMemoryImageCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT - : handleTypes( handleTypes_ ) - {} - - ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlagsNV handleTypes; - }; - static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct ExternalMemoryImageCreateInfoNV : public layout::ExternalMemoryImageCreateInfoNV + struct ExternalMemoryImageCreateInfoNV { VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleTypes_ = vk::ExternalMemoryHandleTypeFlagsNV() ) VULKAN_HPP_NOEXCEPT - : layout::ExternalMemoryImageCreateInfoNV( handleTypes_ ) + : handleTypes( handleTypes_ ) {} + vk::ExternalMemoryImageCreateInfoNV & operator=( vk::ExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalMemoryImageCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalMemoryImageCreateInfoNV( rhs ) - {} + { + *this = rhs; + } ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalMemoryImageCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35080,54 +33132,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalMemoryImageCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlagsNV handleTypes; }; static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct ExternalSemaphoreProperties { - struct ExternalSemaphoreProperties - { - protected: - ExternalSemaphoreProperties() VULKAN_HPP_NOEXCEPT - {} - - ExternalSemaphoreProperties( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ExternalSemaphoreProperties& operator=( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eExternalSemaphoreProperties; - void* pNext = nullptr; - vk::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; - vk::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes; - vk::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures; - }; - static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "layout struct and wrapper have different size!" ); - } - - struct ExternalSemaphoreProperties : public layout::ExternalSemaphoreProperties - { - ExternalSemaphoreProperties() VULKAN_HPP_NOEXCEPT - : layout::ExternalSemaphoreProperties() + ExternalSemaphoreProperties( vk::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes_ = vk::ExternalSemaphoreHandleTypeFlags(), + vk::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes_ = vk::ExternalSemaphoreHandleTypeFlags(), + vk::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures_ = vk::ExternalSemaphoreFeatureFlags() ) VULKAN_HPP_NOEXCEPT + : exportFromImportedHandleTypes( exportFromImportedHandleTypes_ ) + , compatibleHandleTypes( compatibleHandleTypes_ ) + , externalSemaphoreFeatures( externalSemaphoreFeatures_ ) {} + vk::ExternalSemaphoreProperties & operator=( vk::ExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ExternalSemaphoreProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + ExternalSemaphoreProperties( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ExternalSemaphoreProperties( rhs ) - {} + { + *this = rhs; + } ExternalSemaphoreProperties& operator=( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ExternalSemaphoreProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35155,53 +33191,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ExternalSemaphoreProperties::sType; + public: + const vk::StructureType sType = StructureType::eExternalSemaphoreProperties; + void* pNext = nullptr; + vk::ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + vk::ExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + vk::ExternalSemaphoreFeatureFlags externalSemaphoreFeatures; }; static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct FenceCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR FenceCreateInfo( vk::FenceCreateFlags flags_ = vk::FenceCreateFlags() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - {} - - FenceCreateInfo( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFenceCreateInfo; - const void* pNext = nullptr; - vk::FenceCreateFlags flags; - }; - static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct FenceCreateInfo : public layout::FenceCreateInfo + struct FenceCreateInfo { VULKAN_HPP_CONSTEXPR FenceCreateInfo( vk::FenceCreateFlags flags_ = vk::FenceCreateFlags() ) VULKAN_HPP_NOEXCEPT - : layout::FenceCreateInfo( flags_ ) + : flags( flags_ ) {} + vk::FenceCreateInfo & operator=( vk::FenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FenceCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + FenceCreateInfo( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FenceCreateInfo( rhs ) - {} + { + *this = rhs; + } FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FenceCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35239,57 +33258,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FenceCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eFenceCreateInfo; + const void* pNext = nullptr; + vk::FenceCreateFlags flags; }; static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct FenceGetFdInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( vk::Fence fence_ = vk::Fence(), - vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : fence( fence_ ) - , handleType( handleType_ ) - {} - - FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFenceGetFdInfoKHR; - const void* pNext = nullptr; - vk::Fence fence; - vk::ExternalFenceHandleTypeFlagBits handleType; - }; - static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct FenceGetFdInfoKHR : public layout::FenceGetFdInfoKHR + struct FenceGetFdInfoKHR { VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( vk::Fence fence_ = vk::Fence(), vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::FenceGetFdInfoKHR( fence_, handleType_ ) + : fence( fence_ ) + , handleType( handleType_ ) {} + vk::FenceGetFdInfoKHR & operator=( vk::FenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FenceGetFdInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FenceGetFdInfoKHR( rhs ) - {} + { + *this = rhs; + } FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FenceGetFdInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35334,59 +33332,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FenceGetFdInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eFenceGetFdInfoKHR; + const void* pNext = nullptr; + vk::Fence fence; + vk::ExternalFenceHandleTypeFlagBits handleType; }; static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct FenceGetWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(), - vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : fence( fence_ ) - , handleType( handleType_ ) - {} - - FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR; - const void* pNext = nullptr; - vk::Fence fence; - vk::ExternalFenceHandleTypeFlagBits handleType; - }; - static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct FenceGetWin32HandleInfoKHR : public layout::FenceGetWin32HandleInfoKHR + struct FenceGetWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(), vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::FenceGetWin32HandleInfoKHR( fence_, handleType_ ) + : fence( fence_ ) + , handleType( handleType_ ) {} + vk::FenceGetWin32HandleInfoKHR & operator=( vk::FenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FenceGetWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FenceGetWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FenceGetWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35431,54 +33409,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FenceGetWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR; + const void* pNext = nullptr; + vk::Fence fence; + vk::ExternalFenceHandleTypeFlagBits handleType; }; static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout + struct FilterCubicImageViewImageFormatPropertiesEXT { - struct FilterCubicImageViewImageFormatPropertiesEXT - { - protected: - FilterCubicImageViewImageFormatPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - FilterCubicImageViewImageFormatPropertiesEXT( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FilterCubicImageViewImageFormatPropertiesEXT& operator=( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT; - void* pNext = nullptr; - vk::Bool32 filterCubic; - vk::Bool32 filterCubicMinmax; - }; - static_assert( sizeof( FilterCubicImageViewImageFormatPropertiesEXT ) == sizeof( VkFilterCubicImageViewImageFormatPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct FilterCubicImageViewImageFormatPropertiesEXT : public layout::FilterCubicImageViewImageFormatPropertiesEXT - { - FilterCubicImageViewImageFormatPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::FilterCubicImageViewImageFormatPropertiesEXT() + FilterCubicImageViewImageFormatPropertiesEXT( vk::Bool32 filterCubic_ = 0, + vk::Bool32 filterCubicMinmax_ = 0 ) VULKAN_HPP_NOEXCEPT + : filterCubic( filterCubic_ ) + , filterCubicMinmax( filterCubicMinmax_ ) {} + vk::FilterCubicImageViewImageFormatPropertiesEXT & operator=( vk::FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FilterCubicImageViewImageFormatPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + FilterCubicImageViewImageFormatPropertiesEXT( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FilterCubicImageViewImageFormatPropertiesEXT( rhs ) - {} + { + *this = rhs; + } FilterCubicImageViewImageFormatPropertiesEXT& operator=( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FilterCubicImageViewImageFormatPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35505,25 +33467,33 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FilterCubicImageViewImageFormatPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT; + void* pNext = nullptr; + vk::Bool32 filterCubic; + vk::Bool32 filterCubicMinmax; }; static_assert( sizeof( FilterCubicImageViewImageFormatPropertiesEXT ) == sizeof( VkFilterCubicImageViewImageFormatPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct FormatProperties { - FormatProperties() VULKAN_HPP_NOEXCEPT + FormatProperties( vk::FormatFeatureFlags linearTilingFeatures_ = vk::FormatFeatureFlags(), + vk::FormatFeatureFlags optimalTilingFeatures_ = vk::FormatFeatureFlags(), + vk::FormatFeatureFlags bufferFeatures_ = vk::FormatFeatureFlags() ) VULKAN_HPP_NOEXCEPT + : linearTilingFeatures( linearTilingFeatures_ ) + , optimalTilingFeatures( optimalTilingFeatures_ ) + , bufferFeatures( bufferFeatures_ ) {} FormatProperties( VkFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } FormatProperties& operator=( VkFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -35557,46 +33527,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct FormatProperties2 { - struct FormatProperties2 - { - protected: - FormatProperties2() VULKAN_HPP_NOEXCEPT - {} - - FormatProperties2( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FormatProperties2& operator=( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFormatProperties2; - void* pNext = nullptr; - vk::FormatProperties formatProperties; - }; - static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "layout struct and wrapper have different size!" ); - } - - struct FormatProperties2 : public layout::FormatProperties2 - { - FormatProperties2() VULKAN_HPP_NOEXCEPT - : layout::FormatProperties2() + FormatProperties2( vk::FormatProperties formatProperties_ = vk::FormatProperties() ) VULKAN_HPP_NOEXCEPT + : formatProperties( formatProperties_ ) {} + vk::FormatProperties2 & operator=( vk::FormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FormatProperties2 ) - sizeof( vk::StructureType ) ); + return *this; + } + FormatProperties2( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FormatProperties2( rhs ) - {} + { + *this = rhs; + } FormatProperties2& operator=( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FormatProperties2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35622,59 +33572,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FormatProperties2::sType; + public: + const vk::StructureType sType = StructureType::eFormatProperties2; + void* pNext = nullptr; + vk::FormatProperties formatProperties; }; static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct FramebufferAttachmentImageInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfoKHR( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(), - vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(), - uint32_t width_ = 0, - uint32_t height_ = 0, - uint32_t layerCount_ = 0, - uint32_t viewFormatCount_ = 0, - const vk::Format* pViewFormats_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , usage( usage_ ) - , width( width_ ) - , height( height_ ) - , layerCount( layerCount_ ) - , viewFormatCount( viewFormatCount_ ) - , pViewFormats( pViewFormats_ ) - {} - - FramebufferAttachmentImageInfoKHR( VkFramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FramebufferAttachmentImageInfoKHR& operator=( VkFramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFramebufferAttachmentImageInfoKHR; - const void* pNext = nullptr; - vk::ImageCreateFlags flags; - vk::ImageUsageFlags usage; - uint32_t width; - uint32_t height; - uint32_t layerCount; - uint32_t viewFormatCount; - const vk::Format* pViewFormats; - }; - static_assert( sizeof( FramebufferAttachmentImageInfoKHR ) == sizeof( VkFramebufferAttachmentImageInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct FramebufferAttachmentImageInfoKHR : public layout::FramebufferAttachmentImageInfoKHR + struct FramebufferAttachmentImageInfoKHR { VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfoKHR( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(), vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(), @@ -35683,16 +33589,29 @@ namespace VULKAN_HPP_NAMESPACE uint32_t layerCount_ = 0, uint32_t viewFormatCount_ = 0, const vk::Format* pViewFormats_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::FramebufferAttachmentImageInfoKHR( flags_, usage_, width_, height_, layerCount_, viewFormatCount_, pViewFormats_ ) + : flags( flags_ ) + , usage( usage_ ) + , width( width_ ) + , height( height_ ) + , layerCount( layerCount_ ) + , viewFormatCount( viewFormatCount_ ) + , pViewFormats( pViewFormats_ ) {} + vk::FramebufferAttachmentImageInfoKHR & operator=( vk::FramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FramebufferAttachmentImageInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + FramebufferAttachmentImageInfoKHR( VkFramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FramebufferAttachmentImageInfoKHR( rhs ) - {} + { + *this = rhs; + } FramebufferAttachmentImageInfoKHR& operator=( VkFramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FramebufferAttachmentImageInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35772,57 +33691,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FramebufferAttachmentImageInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eFramebufferAttachmentImageInfoKHR; + const void* pNext = nullptr; + vk::ImageCreateFlags flags; + vk::ImageUsageFlags usage; + uint32_t width; + uint32_t height; + uint32_t layerCount; + uint32_t viewFormatCount; + const vk::Format* pViewFormats; }; static_assert( sizeof( FramebufferAttachmentImageInfoKHR ) == sizeof( VkFramebufferAttachmentImageInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct FramebufferAttachmentsCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfoKHR( uint32_t attachmentImageInfoCount_ = 0, - const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ = nullptr ) VULKAN_HPP_NOEXCEPT - : attachmentImageInfoCount( attachmentImageInfoCount_ ) - , pAttachmentImageInfos( pAttachmentImageInfos_ ) - {} - - FramebufferAttachmentsCreateInfoKHR( VkFramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FramebufferAttachmentsCreateInfoKHR& operator=( VkFramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFramebufferAttachmentsCreateInfoKHR; - const void* pNext = nullptr; - uint32_t attachmentImageInfoCount; - const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos; - }; - static_assert( sizeof( FramebufferAttachmentsCreateInfoKHR ) == sizeof( VkFramebufferAttachmentsCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct FramebufferAttachmentsCreateInfoKHR : public layout::FramebufferAttachmentsCreateInfoKHR + struct FramebufferAttachmentsCreateInfoKHR { VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfoKHR( uint32_t attachmentImageInfoCount_ = 0, const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::FramebufferAttachmentsCreateInfoKHR( attachmentImageInfoCount_, pAttachmentImageInfos_ ) + : attachmentImageInfoCount( attachmentImageInfoCount_ ) + , pAttachmentImageInfos( pAttachmentImageInfos_ ) {} + vk::FramebufferAttachmentsCreateInfoKHR & operator=( vk::FramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FramebufferAttachmentsCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + FramebufferAttachmentsCreateInfoKHR( VkFramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FramebufferAttachmentsCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } FramebufferAttachmentsCreateInfoKHR& operator=( VkFramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FramebufferAttachmentsCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -35867,59 +33771,16 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FramebufferAttachmentsCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eFramebufferAttachmentsCreateInfoKHR; + const void* pNext = nullptr; + uint32_t attachmentImageInfoCount; + const vk::FramebufferAttachmentImageInfoKHR* pAttachmentImageInfos; }; static_assert( sizeof( FramebufferAttachmentsCreateInfoKHR ) == sizeof( VkFramebufferAttachmentsCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct FramebufferCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( vk::FramebufferCreateFlags flags_ = vk::FramebufferCreateFlags(), - vk::RenderPass renderPass_ = vk::RenderPass(), - uint32_t attachmentCount_ = 0, - const vk::ImageView* pAttachments_ = nullptr, - uint32_t width_ = 0, - uint32_t height_ = 0, - uint32_t layers_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , renderPass( renderPass_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - , width( width_ ) - , height( height_ ) - , layers( layers_ ) - {} - - FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFramebufferCreateInfo; - const void* pNext = nullptr; - vk::FramebufferCreateFlags flags; - vk::RenderPass renderPass; - uint32_t attachmentCount; - const vk::ImageView* pAttachments; - uint32_t width; - uint32_t height; - uint32_t layers; - }; - static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct FramebufferCreateInfo : public layout::FramebufferCreateInfo + struct FramebufferCreateInfo { VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( vk::FramebufferCreateFlags flags_ = vk::FramebufferCreateFlags(), vk::RenderPass renderPass_ = vk::RenderPass(), @@ -35928,16 +33789,29 @@ namespace VULKAN_HPP_NAMESPACE uint32_t width_ = 0, uint32_t height_ = 0, uint32_t layers_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::FramebufferCreateInfo( flags_, renderPass_, attachmentCount_, pAttachments_, width_, height_, layers_ ) + : flags( flags_ ) + , renderPass( renderPass_ ) + , attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) + , width( width_ ) + , height( height_ ) + , layers( layers_ ) {} + vk::FramebufferCreateInfo & operator=( vk::FramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FramebufferCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FramebufferCreateInfo( rhs ) - {} + { + *this = rhs; + } FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FramebufferCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -36017,55 +33891,46 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FramebufferCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eFramebufferCreateInfo; + const void* pNext = nullptr; + vk::FramebufferCreateFlags flags; + vk::RenderPass renderPass; + uint32_t attachmentCount; + const vk::ImageView* pAttachments; + 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::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct FramebufferMixedSamplesCombinationNV { - struct FramebufferMixedSamplesCombinationNV - { - protected: - FramebufferMixedSamplesCombinationNV() VULKAN_HPP_NOEXCEPT - {} - - FramebufferMixedSamplesCombinationNV( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - FramebufferMixedSamplesCombinationNV& operator=( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eFramebufferMixedSamplesCombinationNV; - void* pNext = nullptr; - vk::CoverageReductionModeNV coverageReductionMode; - vk::SampleCountFlagBits rasterizationSamples; - vk::SampleCountFlags depthStencilSamples; - vk::SampleCountFlags colorSamples; - }; - static_assert( sizeof( FramebufferMixedSamplesCombinationNV ) == sizeof( VkFramebufferMixedSamplesCombinationNV ), "layout struct and wrapper have different size!" ); - } - - struct FramebufferMixedSamplesCombinationNV : public layout::FramebufferMixedSamplesCombinationNV - { - FramebufferMixedSamplesCombinationNV() VULKAN_HPP_NOEXCEPT - : layout::FramebufferMixedSamplesCombinationNV() + FramebufferMixedSamplesCombinationNV( vk::CoverageReductionModeNV coverageReductionMode_ = vk::CoverageReductionModeNV::eMerge, + vk::SampleCountFlagBits rasterizationSamples_ = vk::SampleCountFlagBits::e1, + vk::SampleCountFlags depthStencilSamples_ = vk::SampleCountFlags(), + vk::SampleCountFlags colorSamples_ = vk::SampleCountFlags() ) VULKAN_HPP_NOEXCEPT + : coverageReductionMode( coverageReductionMode_ ) + , rasterizationSamples( rasterizationSamples_ ) + , depthStencilSamples( depthStencilSamples_ ) + , colorSamples( colorSamples_ ) {} + vk::FramebufferMixedSamplesCombinationNV & operator=( vk::FramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::FramebufferMixedSamplesCombinationNV ) - sizeof( vk::StructureType ) ); + return *this; + } + FramebufferMixedSamplesCombinationNV( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::FramebufferMixedSamplesCombinationNV( rhs ) - {} + { + *this = rhs; + } FramebufferMixedSamplesCombinationNV& operator=( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::FramebufferMixedSamplesCombinationNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -36094,8 +33959,13 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::FramebufferMixedSamplesCombinationNV::sType; + public: + const vk::StructureType sType = StructureType::eFramebufferMixedSamplesCombinationNV; + void* pNext = nullptr; + vk::CoverageReductionModeNV coverageReductionMode; + vk::SampleCountFlagBits rasterizationSamples; + vk::SampleCountFlags depthStencilSamples; + vk::SampleCountFlags colorSamples; }; static_assert( sizeof( FramebufferMixedSamplesCombinationNV ) == sizeof( VkFramebufferMixedSamplesCombinationNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -36112,12 +33982,12 @@ namespace VULKAN_HPP_NAMESPACE VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -36183,12 +34053,12 @@ namespace VULKAN_HPP_NAMESPACE VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -36248,63 +34118,34 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineVertexInputStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( vk::PipelineVertexInputStateCreateFlags flags_ = vk::PipelineVertexInputStateCreateFlags(), - uint32_t vertexBindingDescriptionCount_ = 0, - const vk::VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr, - uint32_t vertexAttributeDescriptionCount_ = 0, - const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ ) - , pVertexBindingDescriptions( pVertexBindingDescriptions_ ) - , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ ) - , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ ) - {} - - PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineVertexInputStateCreateFlags flags; - uint32_t vertexBindingDescriptionCount; - const vk::VertexInputBindingDescription* pVertexBindingDescriptions; - uint32_t vertexAttributeDescriptionCount; - const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions; - }; - static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineVertexInputStateCreateInfo : public layout::PipelineVertexInputStateCreateInfo + struct PipelineVertexInputStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( vk::PipelineVertexInputStateCreateFlags flags_ = vk::PipelineVertexInputStateCreateFlags(), uint32_t vertexBindingDescriptionCount_ = 0, const vk::VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr, uint32_t vertexAttributeDescriptionCount_ = 0, const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineVertexInputStateCreateInfo( flags_, vertexBindingDescriptionCount_, pVertexBindingDescriptions_, vertexAttributeDescriptionCount_, pVertexAttributeDescriptions_ ) + : flags( flags_ ) + , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ ) + , pVertexBindingDescriptions( pVertexBindingDescriptions_ ) + , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ ) + , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ ) {} + vk::PipelineVertexInputStateCreateInfo & operator=( vk::PipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineVertexInputStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineVertexInputStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineVertexInputStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -36370,61 +34211,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineVertexInputStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const vk::VertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + const vk::VertexInputAttributeDescription* pVertexAttributeDescriptions; }; static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineInputAssemblyStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( vk::PipelineInputAssemblyStateCreateFlags flags_ = vk::PipelineInputAssemblyStateCreateFlags(), - vk::PrimitiveTopology topology_ = vk::PrimitiveTopology::ePointList, - vk::Bool32 primitiveRestartEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , topology( topology_ ) - , primitiveRestartEnable( primitiveRestartEnable_ ) - {} - - PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineInputAssemblyStateCreateFlags flags; - vk::PrimitiveTopology topology; - vk::Bool32 primitiveRestartEnable; - }; - static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineInputAssemblyStateCreateInfo : public layout::PipelineInputAssemblyStateCreateInfo + struct PipelineInputAssemblyStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( vk::PipelineInputAssemblyStateCreateFlags flags_ = vk::PipelineInputAssemblyStateCreateFlags(), vk::PrimitiveTopology topology_ = vk::PrimitiveTopology::ePointList, vk::Bool32 primitiveRestartEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineInputAssemblyStateCreateInfo( flags_, topology_, primitiveRestartEnable_ ) + : flags( flags_ ) + , topology( topology_ ) + , primitiveRestartEnable( primitiveRestartEnable_ ) {} + vk::PipelineInputAssemblyStateCreateInfo & operator=( vk::PipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineInputAssemblyStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineInputAssemblyStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineInputAssemblyStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -36476,57 +34298,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineInputAssemblyStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineInputAssemblyStateCreateFlags flags; + vk::PrimitiveTopology topology; + vk::Bool32 primitiveRestartEnable; }; static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineTessellationStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( vk::PipelineTessellationStateCreateFlags flags_ = vk::PipelineTessellationStateCreateFlags(), - uint32_t patchControlPoints_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , patchControlPoints( patchControlPoints_ ) - {} - - PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineTessellationStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineTessellationStateCreateFlags flags; - uint32_t patchControlPoints; - }; - static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineTessellationStateCreateInfo : public layout::PipelineTessellationStateCreateInfo + struct PipelineTessellationStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( vk::PipelineTessellationStateCreateFlags flags_ = vk::PipelineTessellationStateCreateFlags(), uint32_t patchControlPoints_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineTessellationStateCreateInfo( flags_, patchControlPoints_ ) + : flags( flags_ ) + , patchControlPoints( patchControlPoints_ ) {} + vk::PipelineTessellationStateCreateInfo & operator=( vk::PipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineTessellationStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineTessellationStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineTessellationStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -36571,8 +34374,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineTessellationStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineTessellationStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; }; static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -36595,12 +34401,12 @@ namespace VULKAN_HPP_NAMESPACE Viewport( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } Viewport& operator=( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -36676,63 +34482,34 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineViewportStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( vk::PipelineViewportStateCreateFlags flags_ = vk::PipelineViewportStateCreateFlags(), - uint32_t viewportCount_ = 0, - const vk::Viewport* pViewports_ = nullptr, - uint32_t scissorCount_ = 0, - const vk::Rect2D* pScissors_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , viewportCount( viewportCount_ ) - , pViewports( pViewports_ ) - , scissorCount( scissorCount_ ) - , pScissors( pScissors_ ) - {} - - PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineViewportStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineViewportStateCreateFlags flags; - uint32_t viewportCount; - const vk::Viewport* pViewports; - uint32_t scissorCount; - const vk::Rect2D* pScissors; - }; - static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineViewportStateCreateInfo : public layout::PipelineViewportStateCreateInfo + struct PipelineViewportStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( vk::PipelineViewportStateCreateFlags flags_ = vk::PipelineViewportStateCreateFlags(), uint32_t viewportCount_ = 0, const vk::Viewport* pViewports_ = nullptr, uint32_t scissorCount_ = 0, const vk::Rect2D* pScissors_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportStateCreateInfo( flags_, viewportCount_, pViewports_, scissorCount_, pScissors_ ) + : flags( flags_ ) + , viewportCount( viewportCount_ ) + , pViewports( pViewports_ ) + , scissorCount( scissorCount_ ) + , pScissors( pScissors_ ) {} + vk::PipelineViewportStateCreateInfo & operator=( vk::PipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineViewportStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -36798,71 +34575,19 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineViewportStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineViewportStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const vk::Viewport* pViewports; + uint32_t scissorCount; + const vk::Rect2D* pScissors; }; static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineRasterizationStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( vk::PipelineRasterizationStateCreateFlags flags_ = vk::PipelineRasterizationStateCreateFlags(), - vk::Bool32 depthClampEnable_ = 0, - vk::Bool32 rasterizerDiscardEnable_ = 0, - vk::PolygonMode polygonMode_ = vk::PolygonMode::eFill, - vk::CullModeFlags cullMode_ = vk::CullModeFlags(), - vk::FrontFace frontFace_ = vk::FrontFace::eCounterClockwise, - vk::Bool32 depthBiasEnable_ = 0, - float depthBiasConstantFactor_ = 0, - float depthBiasClamp_ = 0, - float depthBiasSlopeFactor_ = 0, - float lineWidth_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , depthClampEnable( depthClampEnable_ ) - , rasterizerDiscardEnable( rasterizerDiscardEnable_ ) - , polygonMode( polygonMode_ ) - , cullMode( cullMode_ ) - , frontFace( frontFace_ ) - , depthBiasEnable( depthBiasEnable_ ) - , depthBiasConstantFactor( depthBiasConstantFactor_ ) - , depthBiasClamp( depthBiasClamp_ ) - , depthBiasSlopeFactor( depthBiasSlopeFactor_ ) - , lineWidth( lineWidth_ ) - {} - - PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineRasterizationStateCreateFlags flags; - vk::Bool32 depthClampEnable; - vk::Bool32 rasterizerDiscardEnable; - vk::PolygonMode polygonMode; - vk::CullModeFlags cullMode; - vk::FrontFace frontFace; - vk::Bool32 depthBiasEnable; - float depthBiasConstantFactor; - float depthBiasClamp; - float depthBiasSlopeFactor; - float lineWidth; - }; - static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineRasterizationStateCreateInfo : public layout::PipelineRasterizationStateCreateInfo + struct PipelineRasterizationStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( vk::PipelineRasterizationStateCreateFlags flags_ = vk::PipelineRasterizationStateCreateFlags(), vk::Bool32 depthClampEnable_ = 0, @@ -36875,16 +34600,33 @@ namespace VULKAN_HPP_NAMESPACE float depthBiasClamp_ = 0, float depthBiasSlopeFactor_ = 0, float lineWidth_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationStateCreateInfo( flags_, depthClampEnable_, rasterizerDiscardEnable_, polygonMode_, cullMode_, frontFace_, depthBiasEnable_, depthBiasConstantFactor_, depthBiasClamp_, depthBiasSlopeFactor_, lineWidth_ ) + : flags( flags_ ) + , depthClampEnable( depthClampEnable_ ) + , rasterizerDiscardEnable( rasterizerDiscardEnable_ ) + , polygonMode( polygonMode_ ) + , cullMode( cullMode_ ) + , frontFace( frontFace_ ) + , depthBiasEnable( depthBiasEnable_ ) + , depthBiasConstantFactor( depthBiasConstantFactor_ ) + , depthBiasClamp( depthBiasClamp_ ) + , depthBiasSlopeFactor( depthBiasSlopeFactor_ ) + , lineWidth( lineWidth_ ) {} + vk::PipelineRasterizationStateCreateInfo & operator=( vk::PipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineRasterizationStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -36992,59 +34734,25 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineRasterizationStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineRasterizationStateCreateFlags flags; + vk::Bool32 depthClampEnable; + vk::Bool32 rasterizerDiscardEnable; + vk::PolygonMode polygonMode; + vk::CullModeFlags cullMode; + vk::FrontFace frontFace; + vk::Bool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; }; static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineMultisampleStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( vk::PipelineMultisampleStateCreateFlags flags_ = vk::PipelineMultisampleStateCreateFlags(), - vk::SampleCountFlagBits rasterizationSamples_ = vk::SampleCountFlagBits::e1, - vk::Bool32 sampleShadingEnable_ = 0, - float minSampleShading_ = 0, - const vk::SampleMask* pSampleMask_ = nullptr, - vk::Bool32 alphaToCoverageEnable_ = 0, - vk::Bool32 alphaToOneEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , rasterizationSamples( rasterizationSamples_ ) - , sampleShadingEnable( sampleShadingEnable_ ) - , minSampleShading( minSampleShading_ ) - , pSampleMask( pSampleMask_ ) - , alphaToCoverageEnable( alphaToCoverageEnable_ ) - , alphaToOneEnable( alphaToOneEnable_ ) - {} - - PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineMultisampleStateCreateFlags flags; - vk::SampleCountFlagBits rasterizationSamples; - vk::Bool32 sampleShadingEnable; - float minSampleShading; - const vk::SampleMask* pSampleMask; - vk::Bool32 alphaToCoverageEnable; - vk::Bool32 alphaToOneEnable; - }; - static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineMultisampleStateCreateInfo : public layout::PipelineMultisampleStateCreateInfo + struct PipelineMultisampleStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( vk::PipelineMultisampleStateCreateFlags flags_ = vk::PipelineMultisampleStateCreateFlags(), vk::SampleCountFlagBits rasterizationSamples_ = vk::SampleCountFlagBits::e1, @@ -37053,16 +34761,29 @@ namespace VULKAN_HPP_NAMESPACE const vk::SampleMask* pSampleMask_ = nullptr, vk::Bool32 alphaToCoverageEnable_ = 0, vk::Bool32 alphaToOneEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineMultisampleStateCreateInfo( flags_, rasterizationSamples_, sampleShadingEnable_, minSampleShading_, pSampleMask_, alphaToCoverageEnable_, alphaToOneEnable_ ) + : flags( flags_ ) + , rasterizationSamples( rasterizationSamples_ ) + , sampleShadingEnable( sampleShadingEnable_ ) + , minSampleShading( minSampleShading_ ) + , pSampleMask( pSampleMask_ ) + , alphaToCoverageEnable( alphaToCoverageEnable_ ) + , alphaToOneEnable( alphaToOneEnable_ ) {} + vk::PipelineMultisampleStateCreateInfo & operator=( vk::PipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineMultisampleStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineMultisampleStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineMultisampleStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -37142,8 +34863,16 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineMultisampleStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineMultisampleStateCreateFlags flags; + vk::SampleCountFlagBits rasterizationSamples; + vk::Bool32 sampleShadingEnable; + float minSampleShading; + const vk::SampleMask* pSampleMask; + vk::Bool32 alphaToCoverageEnable; + vk::Bool32 alphaToOneEnable; }; static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -37168,12 +34897,12 @@ namespace VULKAN_HPP_NAMESPACE StencilOpState( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } StencilOpState& operator=( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -37257,62 +34986,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineDepthStencilStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( vk::PipelineDepthStencilStateCreateFlags flags_ = vk::PipelineDepthStencilStateCreateFlags(), - vk::Bool32 depthTestEnable_ = 0, - vk::Bool32 depthWriteEnable_ = 0, - vk::CompareOp depthCompareOp_ = vk::CompareOp::eNever, - vk::Bool32 depthBoundsTestEnable_ = 0, - vk::Bool32 stencilTestEnable_ = 0, - vk::StencilOpState front_ = vk::StencilOpState(), - vk::StencilOpState back_ = vk::StencilOpState(), - float minDepthBounds_ = 0, - float maxDepthBounds_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , depthTestEnable( depthTestEnable_ ) - , depthWriteEnable( depthWriteEnable_ ) - , depthCompareOp( depthCompareOp_ ) - , depthBoundsTestEnable( depthBoundsTestEnable_ ) - , stencilTestEnable( stencilTestEnable_ ) - , front( front_ ) - , back( back_ ) - , minDepthBounds( minDepthBounds_ ) - , maxDepthBounds( maxDepthBounds_ ) - {} - - PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineDepthStencilStateCreateFlags flags; - vk::Bool32 depthTestEnable; - vk::Bool32 depthWriteEnable; - vk::CompareOp depthCompareOp; - vk::Bool32 depthBoundsTestEnable; - vk::Bool32 stencilTestEnable; - vk::StencilOpState front; - vk::StencilOpState back; - float minDepthBounds; - float maxDepthBounds; - }; - static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineDepthStencilStateCreateInfo : public layout::PipelineDepthStencilStateCreateInfo + struct PipelineDepthStencilStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( vk::PipelineDepthStencilStateCreateFlags flags_ = vk::PipelineDepthStencilStateCreateFlags(), vk::Bool32 depthTestEnable_ = 0, @@ -37324,16 +34998,32 @@ namespace VULKAN_HPP_NAMESPACE vk::StencilOpState back_ = vk::StencilOpState(), float minDepthBounds_ = 0, float maxDepthBounds_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineDepthStencilStateCreateInfo( flags_, depthTestEnable_, depthWriteEnable_, depthCompareOp_, depthBoundsTestEnable_, stencilTestEnable_, front_, back_, minDepthBounds_, maxDepthBounds_ ) + : flags( flags_ ) + , depthTestEnable( depthTestEnable_ ) + , depthWriteEnable( depthWriteEnable_ ) + , depthCompareOp( depthCompareOp_ ) + , depthBoundsTestEnable( depthBoundsTestEnable_ ) + , stencilTestEnable( stencilTestEnable_ ) + , front( front_ ) + , back( back_ ) + , minDepthBounds( minDepthBounds_ ) + , maxDepthBounds( maxDepthBounds_ ) {} + vk::PipelineDepthStencilStateCreateInfo & operator=( vk::PipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineDepthStencilStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineDepthStencilStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineDepthStencilStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -37434,8 +35124,19 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineDepthStencilStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineDepthStencilStateCreateFlags flags; + vk::Bool32 depthTestEnable; + vk::Bool32 depthWriteEnable; + vk::CompareOp depthCompareOp; + vk::Bool32 depthBoundsTestEnable; + vk::Bool32 stencilTestEnable; + vk::StencilOpState front; + vk::StencilOpState back; + float minDepthBounds; + float maxDepthBounds; }; static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -37462,12 +35163,12 @@ namespace VULKAN_HPP_NAMESPACE PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -37559,52 +35260,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineColorBlendStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( vk::PipelineColorBlendStateCreateFlags flags_ = vk::PipelineColorBlendStateCreateFlags(), - vk::Bool32 logicOpEnable_ = 0, - vk::LogicOp logicOp_ = vk::LogicOp::eClear, - uint32_t attachmentCount_ = 0, - const vk::PipelineColorBlendAttachmentState* pAttachments_ = nullptr, - std::array const& blendConstants_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , logicOpEnable( logicOpEnable_ ) - , logicOp( logicOp_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - , blendConstants{} - { - vk::ConstExpressionArrayCopy::copy( blendConstants, blendConstants_ ); - } - - PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineColorBlendStateCreateFlags flags; - vk::Bool32 logicOpEnable; - vk::LogicOp logicOp; - uint32_t attachmentCount; - const vk::PipelineColorBlendAttachmentState* pAttachments; - float blendConstants[4]; - }; - static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineColorBlendStateCreateInfo : public layout::PipelineColorBlendStateCreateInfo + struct PipelineColorBlendStateCreateInfo { VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( vk::PipelineColorBlendStateCreateFlags flags_ = vk::PipelineColorBlendStateCreateFlags(), vk::Bool32 logicOpEnable_ = 0, @@ -37612,16 +35268,30 @@ namespace VULKAN_HPP_NAMESPACE uint32_t attachmentCount_ = 0, const vk::PipelineColorBlendAttachmentState* pAttachments_ = nullptr, std::array const& blendConstants_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT - : layout::PipelineColorBlendStateCreateInfo( flags_, logicOpEnable_, logicOp_, attachmentCount_, pAttachments_, blendConstants_ ) - {} + : flags( flags_ ) + , logicOpEnable( logicOpEnable_ ) + , logicOp( logicOp_ ) + , attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) + , blendConstants{} + { + vk::ConstExpressionArrayCopy::copy( blendConstants, blendConstants_ ); + } + + vk::PipelineColorBlendStateCreateInfo & operator=( vk::PipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineColorBlendStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineColorBlendStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineColorBlendStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -37694,61 +35364,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineColorBlendStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineColorBlendStateCreateFlags flags; + vk::Bool32 logicOpEnable; + vk::LogicOp logicOp; + uint32_t attachmentCount; + const vk::PipelineColorBlendAttachmentState* pAttachments; + float blendConstants[4]; }; static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineDynamicStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( vk::PipelineDynamicStateCreateFlags flags_ = vk::PipelineDynamicStateCreateFlags(), - uint32_t dynamicStateCount_ = 0, - const vk::DynamicState* pDynamicStates_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , dynamicStateCount( dynamicStateCount_ ) - , pDynamicStates( pDynamicStates_ ) - {} - - PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineDynamicStateCreateInfo; - const void* pNext = nullptr; - vk::PipelineDynamicStateCreateFlags flags; - uint32_t dynamicStateCount; - const vk::DynamicState* pDynamicStates; - }; - static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineDynamicStateCreateInfo : public layout::PipelineDynamicStateCreateInfo + struct PipelineDynamicStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( vk::PipelineDynamicStateCreateFlags flags_ = vk::PipelineDynamicStateCreateFlags(), uint32_t dynamicStateCount_ = 0, const vk::DynamicState* pDynamicStates_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineDynamicStateCreateInfo( flags_, dynamicStateCount_, pDynamicStates_ ) + : flags( flags_ ) + , dynamicStateCount( dynamicStateCount_ ) + , pDynamicStates( pDynamicStates_ ) {} + vk::PipelineDynamicStateCreateInfo & operator=( vk::PipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineDynamicStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineDynamicStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineDynamicStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -37800,89 +35452,17 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineDynamicStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineDynamicStateCreateInfo; + const void* pNext = nullptr; + vk::PipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const vk::DynamicState* pDynamicStates; }; static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct GraphicsPipelineCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR GraphicsPipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(), - uint32_t stageCount_ = 0, - const vk::PipelineShaderStageCreateInfo* pStages_ = nullptr, - const vk::PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr, - const vk::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr, - const vk::PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr, - const vk::PipelineViewportStateCreateInfo* pViewportState_ = nullptr, - const vk::PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr, - const vk::PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr, - const vk::PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr, - const vk::PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr, - const vk::PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr, - vk::PipelineLayout layout_ = vk::PipelineLayout(), - vk::RenderPass renderPass_ = vk::RenderPass(), - uint32_t subpass_ = 0, - vk::Pipeline basePipelineHandle_ = vk::Pipeline(), - int32_t basePipelineIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , stageCount( stageCount_ ) - , pStages( pStages_ ) - , pVertexInputState( pVertexInputState_ ) - , pInputAssemblyState( pInputAssemblyState_ ) - , pTessellationState( pTessellationState_ ) - , pViewportState( pViewportState_ ) - , pRasterizationState( pRasterizationState_ ) - , pMultisampleState( pMultisampleState_ ) - , pDepthStencilState( pDepthStencilState_ ) - , pColorBlendState( pColorBlendState_ ) - , pDynamicState( pDynamicState_ ) - , layout( layout_ ) - , renderPass( renderPass_ ) - , subpass( subpass_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - {} - - GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eGraphicsPipelineCreateInfo; - const void* pNext = nullptr; - vk::PipelineCreateFlags flags; - uint32_t stageCount; - const vk::PipelineShaderStageCreateInfo* pStages; - const vk::PipelineVertexInputStateCreateInfo* pVertexInputState; - const vk::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState; - const vk::PipelineTessellationStateCreateInfo* pTessellationState; - const vk::PipelineViewportStateCreateInfo* pViewportState; - const vk::PipelineRasterizationStateCreateInfo* pRasterizationState; - const vk::PipelineMultisampleStateCreateInfo* pMultisampleState; - const vk::PipelineDepthStencilStateCreateInfo* pDepthStencilState; - const vk::PipelineColorBlendStateCreateInfo* pColorBlendState; - const vk::PipelineDynamicStateCreateInfo* pDynamicState; - vk::PipelineLayout layout; - vk::RenderPass renderPass; - uint32_t subpass; - vk::Pipeline basePipelineHandle; - int32_t basePipelineIndex; - }; - static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct GraphicsPipelineCreateInfo : public layout::GraphicsPipelineCreateInfo + struct GraphicsPipelineCreateInfo { VULKAN_HPP_CONSTEXPR GraphicsPipelineCreateInfo( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(), uint32_t stageCount_ = 0, @@ -37901,16 +35481,39 @@ namespace VULKAN_HPP_NAMESPACE uint32_t subpass_ = 0, vk::Pipeline basePipelineHandle_ = vk::Pipeline(), int32_t basePipelineIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::GraphicsPipelineCreateInfo( flags_, stageCount_, pStages_, pVertexInputState_, pInputAssemblyState_, pTessellationState_, pViewportState_, pRasterizationState_, pMultisampleState_, pDepthStencilState_, pColorBlendState_, pDynamicState_, layout_, renderPass_, subpass_, basePipelineHandle_, basePipelineIndex_ ) + : flags( flags_ ) + , stageCount( stageCount_ ) + , pStages( pStages_ ) + , pVertexInputState( pVertexInputState_ ) + , pInputAssemblyState( pInputAssemblyState_ ) + , pTessellationState( pTessellationState_ ) + , pViewportState( pViewportState_ ) + , pRasterizationState( pRasterizationState_ ) + , pMultisampleState( pMultisampleState_ ) + , pDepthStencilState( pDepthStencilState_ ) + , pColorBlendState( pColorBlendState_ ) + , pDynamicState( pDynamicState_ ) + , layout( layout_ ) + , renderPass( renderPass_ ) + , subpass( subpass_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) {} + vk::GraphicsPipelineCreateInfo & operator=( vk::GraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::GraphicsPipelineCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::GraphicsPipelineCreateInfo( rhs ) - {} + { + *this = rhs; + } GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::GraphicsPipelineCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -38060,8 +35663,26 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::GraphicsPipelineCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eGraphicsPipelineCreateInfo; + const void* pNext = nullptr; + vk::PipelineCreateFlags flags; + uint32_t stageCount; + const vk::PipelineShaderStageCreateInfo* pStages; + const vk::PipelineVertexInputStateCreateInfo* pVertexInputState; + const vk::PipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const vk::PipelineTessellationStateCreateInfo* pTessellationState; + const vk::PipelineViewportStateCreateInfo* pViewportState; + const vk::PipelineRasterizationStateCreateInfo* pRasterizationState; + const vk::PipelineMultisampleStateCreateInfo* pMultisampleState; + const vk::PipelineDepthStencilStateCreateInfo* pDepthStencilState; + const vk::PipelineColorBlendStateCreateInfo* pColorBlendState; + const vk::PipelineDynamicStateCreateInfo* pDynamicState; + vk::PipelineLayout layout; + vk::RenderPass renderPass; + uint32_t subpass; + vk::Pipeline basePipelineHandle; + int32_t basePipelineIndex; }; static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -38076,12 +35697,12 @@ namespace VULKAN_HPP_NAMESPACE XYColorEXT( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } XYColorEXT& operator=( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -38125,56 +35746,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct HdrMetadataEXT - { - protected: - VULKAN_HPP_CONSTEXPR HdrMetadataEXT( vk::XYColorEXT displayPrimaryRed_ = vk::XYColorEXT(), - vk::XYColorEXT displayPrimaryGreen_ = vk::XYColorEXT(), - vk::XYColorEXT displayPrimaryBlue_ = vk::XYColorEXT(), - vk::XYColorEXT whitePoint_ = vk::XYColorEXT(), - float maxLuminance_ = 0, - float minLuminance_ = 0, - float maxContentLightLevel_ = 0, - float maxFrameAverageLightLevel_ = 0 ) VULKAN_HPP_NOEXCEPT - : displayPrimaryRed( displayPrimaryRed_ ) - , displayPrimaryGreen( displayPrimaryGreen_ ) - , displayPrimaryBlue( displayPrimaryBlue_ ) - , whitePoint( whitePoint_ ) - , maxLuminance( maxLuminance_ ) - , minLuminance( minLuminance_ ) - , maxContentLightLevel( maxContentLightLevel_ ) - , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ ) - {} - - HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eHdrMetadataEXT; - const void* pNext = nullptr; - vk::XYColorEXT displayPrimaryRed; - vk::XYColorEXT displayPrimaryGreen; - vk::XYColorEXT displayPrimaryBlue; - vk::XYColorEXT whitePoint; - float maxLuminance; - float minLuminance; - float maxContentLightLevel; - float maxFrameAverageLightLevel; - }; - static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "layout struct and wrapper have different size!" ); - } - - struct HdrMetadataEXT : public layout::HdrMetadataEXT + struct HdrMetadataEXT { VULKAN_HPP_CONSTEXPR HdrMetadataEXT( vk::XYColorEXT displayPrimaryRed_ = vk::XYColorEXT(), vk::XYColorEXT displayPrimaryGreen_ = vk::XYColorEXT(), @@ -38184,16 +35756,30 @@ namespace VULKAN_HPP_NAMESPACE float minLuminance_ = 0, float maxContentLightLevel_ = 0, float maxFrameAverageLightLevel_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::HdrMetadataEXT( displayPrimaryRed_, displayPrimaryGreen_, displayPrimaryBlue_, whitePoint_, maxLuminance_, minLuminance_, maxContentLightLevel_, maxFrameAverageLightLevel_ ) + : displayPrimaryRed( displayPrimaryRed_ ) + , displayPrimaryGreen( displayPrimaryGreen_ ) + , displayPrimaryBlue( displayPrimaryBlue_ ) + , whitePoint( whitePoint_ ) + , maxLuminance( maxLuminance_ ) + , minLuminance( minLuminance_ ) + , maxContentLightLevel( maxContentLightLevel_ ) + , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ ) {} + vk::HdrMetadataEXT & operator=( vk::HdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::HdrMetadataEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::HdrMetadataEXT( rhs ) - {} + { + *this = rhs; + } HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::HdrMetadataEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -38280,53 +35866,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::HdrMetadataEXT::sType; + public: + const vk::StructureType sType = StructureType::eHdrMetadataEXT; + const void* pNext = nullptr; + vk::XYColorEXT displayPrimaryRed; + vk::XYColorEXT displayPrimaryGreen; + vk::XYColorEXT displayPrimaryBlue; + vk::XYColorEXT whitePoint; + float maxLuminance; + float minLuminance; + float maxContentLightLevel; + float maxFrameAverageLightLevel; }; static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct HeadlessSurfaceCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( vk::HeadlessSurfaceCreateFlagsEXT flags_ = vk::HeadlessSurfaceCreateFlagsEXT() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - {} - - HeadlessSurfaceCreateInfoEXT( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - HeadlessSurfaceCreateInfoEXT& operator=( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eHeadlessSurfaceCreateInfoEXT; - const void* pNext = nullptr; - vk::HeadlessSurfaceCreateFlagsEXT flags; - }; - static_assert( sizeof( HeadlessSurfaceCreateInfoEXT ) == sizeof( VkHeadlessSurfaceCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct HeadlessSurfaceCreateInfoEXT : public layout::HeadlessSurfaceCreateInfoEXT + struct HeadlessSurfaceCreateInfoEXT { VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( vk::HeadlessSurfaceCreateFlagsEXT flags_ = vk::HeadlessSurfaceCreateFlagsEXT() ) VULKAN_HPP_NOEXCEPT - : layout::HeadlessSurfaceCreateInfoEXT( flags_ ) + : flags( flags_ ) {} + vk::HeadlessSurfaceCreateInfoEXT & operator=( vk::HeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::HeadlessSurfaceCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + HeadlessSurfaceCreateInfoEXT( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::HeadlessSurfaceCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } HeadlessSurfaceCreateInfoEXT& operator=( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::HeadlessSurfaceCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -38364,59 +35938,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::HeadlessSurfaceCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eHeadlessSurfaceCreateInfoEXT; + const void* pNext = nullptr; + vk::HeadlessSurfaceCreateFlagsEXT flags; }; static_assert( sizeof( HeadlessSurfaceCreateInfoEXT ) == sizeof( VkHeadlessSurfaceCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_IOS_MVK - namespace layout - { - struct IOSSurfaceCreateInfoMVK - { - protected: - VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( vk::IOSSurfaceCreateFlagsMVK flags_ = vk::IOSSurfaceCreateFlagsMVK(), - const void* pView_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pView( pView_ ) - {} - - IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eIosSurfaceCreateInfoMVK; - const void* pNext = nullptr; - vk::IOSSurfaceCreateFlagsMVK flags; - const void* pView; - }; - static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "layout struct and wrapper have different size!" ); - } - - struct IOSSurfaceCreateInfoMVK : public layout::IOSSurfaceCreateInfoMVK + struct IOSSurfaceCreateInfoMVK { VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( vk::IOSSurfaceCreateFlagsMVK flags_ = vk::IOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::IOSSurfaceCreateInfoMVK( flags_, pView_ ) + : flags( flags_ ) + , pView( pView_ ) {} + vk::IOSSurfaceCreateInfoMVK & operator=( vk::IOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::IOSSurfaceCreateInfoMVK ) - sizeof( vk::StructureType ) ); + return *this; + } + IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::IOSSurfaceCreateInfoMVK( rhs ) - {} + { + *this = rhs; + } IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::IOSSurfaceCreateInfoMVK::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -38461,8 +36014,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::IOSSurfaceCreateInfoMVK::sType; + public: + const vk::StructureType sType = StructureType::eIosSurfaceCreateInfoMVK; + const void* pNext = nullptr; + vk::IOSSurfaceCreateFlagsMVK flags; + const void* pView; }; static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -38485,12 +36041,12 @@ namespace VULKAN_HPP_NAMESPACE ImageBlit( VkImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ImageBlit& operator=( VkImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -38566,12 +36122,12 @@ namespace VULKAN_HPP_NAMESPACE ImageCopy( VkImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ImageCopy& operator=( VkImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -38639,71 +36195,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ImageCreateInfo( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(), - vk::ImageType imageType_ = vk::ImageType::e1D, - vk::Format format_ = vk::Format::eUndefined, - vk::Extent3D extent_ = vk::Extent3D(), - uint32_t mipLevels_ = 0, - uint32_t arrayLayers_ = 0, - vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1, - vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal, - vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(), - vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = 0, - const uint32_t* pQueueFamilyIndices_ = nullptr, - vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , imageType( imageType_ ) - , format( format_ ) - , extent( extent_ ) - , mipLevels( mipLevels_ ) - , arrayLayers( arrayLayers_ ) - , samples( samples_ ) - , tiling( tiling_ ) - , usage( usage_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - , initialLayout( initialLayout_ ) - {} - - ImageCreateInfo( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageCreateInfo& operator=( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageCreateInfo; - const void* pNext = nullptr; - vk::ImageCreateFlags flags; - vk::ImageType imageType; - vk::Format format; - vk::Extent3D extent; - uint32_t mipLevels; - uint32_t arrayLayers; - vk::SampleCountFlagBits samples; - vk::ImageTiling tiling; - vk::ImageUsageFlags usage; - vk::SharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - vk::ImageLayout initialLayout; - }; - static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ImageCreateInfo : public layout::ImageCreateInfo + struct ImageCreateInfo { VULKAN_HPP_CONSTEXPR ImageCreateInfo( vk::ImageCreateFlags flags_ = vk::ImageCreateFlags(), vk::ImageType imageType_ = vk::ImageType::e1D, @@ -38718,16 +36210,35 @@ namespace VULKAN_HPP_NAMESPACE uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr, vk::ImageLayout initialLayout_ = vk::ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : layout::ImageCreateInfo( flags_, imageType_, format_, extent_, mipLevels_, arrayLayers_, samples_, tiling_, usage_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_, initialLayout_ ) + : flags( flags_ ) + , imageType( imageType_ ) + , format( format_ ) + , extent( extent_ ) + , mipLevels( mipLevels_ ) + , arrayLayers( arrayLayers_ ) + , samples( samples_ ) + , tiling( tiling_ ) + , usage( usage_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( queueFamilyIndexCount_ ) + , pQueueFamilyIndices( pQueueFamilyIndices_ ) + , initialLayout( initialLayout_ ) {} + vk::ImageCreateInfo & operator=( vk::ImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageCreateInfo( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageCreateInfo( rhs ) - {} + { + *this = rhs; + } ImageCreateInfo& operator=( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -38849,25 +36360,48 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eImageCreateInfo; + const void* pNext = nullptr; + vk::ImageCreateFlags flags; + vk::ImageType imageType; + vk::Format format; + vk::Extent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + vk::SampleCountFlagBits samples; + vk::ImageTiling tiling; + vk::ImageUsageFlags usage; + vk::SharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + vk::ImageLayout initialLayout; }; static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct SubresourceLayout { - SubresourceLayout() VULKAN_HPP_NOEXCEPT + SubresourceLayout( vk::DeviceSize offset_ = 0, + vk::DeviceSize size_ = 0, + vk::DeviceSize rowPitch_ = 0, + vk::DeviceSize arrayPitch_ = 0, + vk::DeviceSize depthPitch_ = 0 ) VULKAN_HPP_NOEXCEPT + : offset( offset_ ) + , size( size_ ) + , rowPitch( rowPitch_ ) + , arrayPitch( arrayPitch_ ) + , depthPitch( depthPitch_ ) {} SubresourceLayout( VkSubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SubresourceLayout& operator=( VkSubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -38905,55 +36439,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageDrmFormatModifierExplicitCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0, - uint32_t drmFormatModifierPlaneCount_ = 0, - const vk::SubresourceLayout* pPlaneLayouts_ = nullptr ) VULKAN_HPP_NOEXCEPT - : drmFormatModifier( drmFormatModifier_ ) - , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ ) - , pPlaneLayouts( pPlaneLayouts_ ) - {} - - ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT; - const void* pNext = nullptr; - uint64_t drmFormatModifier; - uint32_t drmFormatModifierPlaneCount; - const vk::SubresourceLayout* pPlaneLayouts; - }; - static_assert( sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct ImageDrmFormatModifierExplicitCreateInfoEXT : public layout::ImageDrmFormatModifierExplicitCreateInfoEXT + struct ImageDrmFormatModifierExplicitCreateInfoEXT { VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = 0, uint32_t drmFormatModifierPlaneCount_ = 0, const vk::SubresourceLayout* pPlaneLayouts_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImageDrmFormatModifierExplicitCreateInfoEXT( drmFormatModifier_, drmFormatModifierPlaneCount_, pPlaneLayouts_ ) + : drmFormatModifier( drmFormatModifier_ ) + , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ ) + , pPlaneLayouts( pPlaneLayouts_ ) {} + vk::ImageDrmFormatModifierExplicitCreateInfoEXT & operator=( vk::ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageDrmFormatModifierExplicitCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageDrmFormatModifierExplicitCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageDrmFormatModifierExplicitCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39005,57 +36514,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageDrmFormatModifierExplicitCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT; + const void* pNext = nullptr; + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + const vk::SubresourceLayout* pPlaneLayouts; }; static_assert( sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageDrmFormatModifierListCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0, - const uint64_t* pDrmFormatModifiers_ = nullptr ) VULKAN_HPP_NOEXCEPT - : drmFormatModifierCount( drmFormatModifierCount_ ) - , pDrmFormatModifiers( pDrmFormatModifiers_ ) - {} - - ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT; - const void* pNext = nullptr; - uint32_t drmFormatModifierCount; - const uint64_t* pDrmFormatModifiers; - }; - static_assert( sizeof( ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct ImageDrmFormatModifierListCreateInfoEXT : public layout::ImageDrmFormatModifierListCreateInfoEXT + struct ImageDrmFormatModifierListCreateInfoEXT { VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = 0, const uint64_t* pDrmFormatModifiers_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImageDrmFormatModifierListCreateInfoEXT( drmFormatModifierCount_, pDrmFormatModifiers_ ) + : drmFormatModifierCount( drmFormatModifierCount_ ) + , pDrmFormatModifiers( pDrmFormatModifiers_ ) {} + vk::ImageDrmFormatModifierListCreateInfoEXT & operator=( vk::ImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageDrmFormatModifierListCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageDrmFormatModifierListCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageDrmFormatModifierListCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39100,52 +36590,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageDrmFormatModifierListCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT; + const void* pNext = nullptr; + 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::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct ImageDrmFormatModifierPropertiesEXT { - struct ImageDrmFormatModifierPropertiesEXT - { - protected: - ImageDrmFormatModifierPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - ImageDrmFormatModifierPropertiesEXT( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageDrmFormatModifierPropertiesEXT& operator=( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT; - void* pNext = nullptr; - uint64_t drmFormatModifier; - }; - static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct ImageDrmFormatModifierPropertiesEXT : public layout::ImageDrmFormatModifierPropertiesEXT - { - ImageDrmFormatModifierPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::ImageDrmFormatModifierPropertiesEXT() + ImageDrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = 0 ) VULKAN_HPP_NOEXCEPT + : drmFormatModifier( drmFormatModifier_ ) {} + vk::ImageDrmFormatModifierPropertiesEXT & operator=( vk::ImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageDrmFormatModifierPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageDrmFormatModifierPropertiesEXT( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageDrmFormatModifierPropertiesEXT( rhs ) - {} + { + *this = rhs; + } ImageDrmFormatModifierPropertiesEXT& operator=( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageDrmFormatModifierPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39171,57 +36644,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageDrmFormatModifierPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT; + void* pNext = nullptr; + uint64_t drmFormatModifier; }; static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageFormatListCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0, - const vk::Format* pViewFormats_ = nullptr ) VULKAN_HPP_NOEXCEPT - : viewFormatCount( viewFormatCount_ ) - , pViewFormats( pViewFormats_ ) - {} - - ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageFormatListCreateInfoKHR; - const void* pNext = nullptr; - uint32_t viewFormatCount; - const vk::Format* pViewFormats; - }; - static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImageFormatListCreateInfoKHR : public layout::ImageFormatListCreateInfoKHR + struct ImageFormatListCreateInfoKHR { VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0, const vk::Format* pViewFormats_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImageFormatListCreateInfoKHR( viewFormatCount_, pViewFormats_ ) + : viewFormatCount( viewFormatCount_ ) + , pViewFormats( pViewFormats_ ) {} + vk::ImageFormatListCreateInfoKHR & operator=( vk::ImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageFormatListCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageFormatListCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageFormatListCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39266,52 +36718,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageFormatListCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImageFormatListCreateInfoKHR; + const void* pNext = nullptr; + uint32_t viewFormatCount; + const vk::Format* pViewFormats; }; static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct ImageFormatProperties2 { - struct ImageFormatProperties2 - { - protected: - ImageFormatProperties2() VULKAN_HPP_NOEXCEPT - {} - - ImageFormatProperties2( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageFormatProperties2& operator=( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageFormatProperties2; - void* pNext = nullptr; - vk::ImageFormatProperties imageFormatProperties; - }; - static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "layout struct and wrapper have different size!" ); - } - - struct ImageFormatProperties2 : public layout::ImageFormatProperties2 - { - ImageFormatProperties2() VULKAN_HPP_NOEXCEPT - : layout::ImageFormatProperties2() + ImageFormatProperties2( vk::ImageFormatProperties imageFormatProperties_ = vk::ImageFormatProperties() ) VULKAN_HPP_NOEXCEPT + : imageFormatProperties( imageFormatProperties_ ) {} + vk::ImageFormatProperties2 & operator=( vk::ImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageFormatProperties2 ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageFormatProperties2( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageFormatProperties2( rhs ) - {} + { + *this = rhs; + } ImageFormatProperties2& operator=( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageFormatProperties2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39337,8 +36772,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageFormatProperties2::sType; + public: + const vk::StructureType sType = StructureType::eImageFormatProperties2; + void* pNext = nullptr; + vk::ImageFormatProperties imageFormatProperties; }; static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -39359,12 +36796,12 @@ namespace VULKAN_HPP_NAMESPACE ImageSubresourceRange( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -39432,56 +36869,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageMemoryBarrier - { - protected: - VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(), - vk::AccessFlags dstAccessMask_ = vk::AccessFlags(), - vk::ImageLayout oldLayout_ = vk::ImageLayout::eUndefined, - vk::ImageLayout newLayout_ = vk::ImageLayout::eUndefined, - uint32_t srcQueueFamilyIndex_ = 0, - uint32_t dstQueueFamilyIndex_ = 0, - vk::Image image_ = vk::Image(), - vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() ) VULKAN_HPP_NOEXCEPT - : srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , oldLayout( oldLayout_ ) - , newLayout( newLayout_ ) - , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) - , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) - , image( image_ ) - , subresourceRange( subresourceRange_ ) - {} - - ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageMemoryBarrier; - const void* pNext = nullptr; - vk::AccessFlags srcAccessMask; - vk::AccessFlags dstAccessMask; - vk::ImageLayout oldLayout; - vk::ImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - vk::Image image; - vk::ImageSubresourceRange subresourceRange; - }; - static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "layout struct and wrapper have different size!" ); - } - - struct ImageMemoryBarrier : public layout::ImageMemoryBarrier + struct ImageMemoryBarrier { VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(), vk::AccessFlags dstAccessMask_ = vk::AccessFlags(), @@ -39491,16 +36879,30 @@ namespace VULKAN_HPP_NAMESPACE uint32_t dstQueueFamilyIndex_ = 0, vk::Image image_ = vk::Image(), vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() ) VULKAN_HPP_NOEXCEPT - : layout::ImageMemoryBarrier( srcAccessMask_, dstAccessMask_, oldLayout_, newLayout_, srcQueueFamilyIndex_, dstQueueFamilyIndex_, image_, subresourceRange_ ) + : srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) + , oldLayout( oldLayout_ ) + , newLayout( newLayout_ ) + , srcQueueFamilyIndex( srcQueueFamilyIndex_ ) + , dstQueueFamilyIndex( dstQueueFamilyIndex_ ) + , image( image_ ) + , subresourceRange( subresourceRange_ ) {} + vk::ImageMemoryBarrier & operator=( vk::ImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageMemoryBarrier ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageMemoryBarrier( rhs ) - {} + { + *this = rhs; + } ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageMemoryBarrier::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39587,53 +36989,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageMemoryBarrier::sType; + public: + const vk::StructureType sType = StructureType::eImageMemoryBarrier; + const void* pNext = nullptr; + vk::AccessFlags srcAccessMask; + vk::AccessFlags dstAccessMask; + vk::ImageLayout oldLayout; + vk::ImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + vk::Image image; + vk::ImageSubresourceRange subresourceRange; }; static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageMemoryRequirementsInfo2 - { - protected: - VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( vk::Image image_ = vk::Image() ) VULKAN_HPP_NOEXCEPT - : image( image_ ) - {} - - ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageMemoryRequirementsInfo2; - const void* pNext = nullptr; - vk::Image image; - }; - static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "layout struct and wrapper have different size!" ); - } - - struct ImageMemoryRequirementsInfo2 : public layout::ImageMemoryRequirementsInfo2 + struct ImageMemoryRequirementsInfo2 { VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( vk::Image image_ = vk::Image() ) VULKAN_HPP_NOEXCEPT - : layout::ImageMemoryRequirementsInfo2( image_ ) + : image( image_ ) {} + vk::ImageMemoryRequirementsInfo2 & operator=( vk::ImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageMemoryRequirementsInfo2 ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageMemoryRequirementsInfo2( rhs ) - {} + { + *this = rhs; + } ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageMemoryRequirementsInfo2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39671,59 +37061,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageMemoryRequirementsInfo2::sType; + public: + const vk::StructureType sType = StructureType::eImageMemoryRequirementsInfo2; + const void* pNext = nullptr; + vk::Image image; }; static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_FUCHSIA - namespace layout - { - struct ImagePipeSurfaceCreateInfoFUCHSIA - { - protected: - VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = vk::ImagePipeSurfaceCreateFlagsFUCHSIA(), - zx_handle_t imagePipeHandle_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , imagePipeHandle( imagePipeHandle_ ) - {} - - ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA; - const void* pNext = nullptr; - vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags; - zx_handle_t imagePipeHandle; - }; - static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "layout struct and wrapper have different size!" ); - } - - struct ImagePipeSurfaceCreateInfoFUCHSIA : public layout::ImagePipeSurfaceCreateInfoFUCHSIA + struct ImagePipeSurfaceCreateInfoFUCHSIA { VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = vk::ImagePipeSurfaceCreateFlagsFUCHSIA(), zx_handle_t imagePipeHandle_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ImagePipeSurfaceCreateInfoFUCHSIA( flags_, imagePipeHandle_ ) + : flags( flags_ ) + , imagePipeHandle( imagePipeHandle_ ) {} + vk::ImagePipeSurfaceCreateInfoFUCHSIA & operator=( vk::ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImagePipeSurfaceCreateInfoFUCHSIA ) - sizeof( vk::StructureType ) ); + return *this; + } + ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImagePipeSurfaceCreateInfoFUCHSIA( rhs ) - {} + { + *this = rhs; + } ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImagePipeSurfaceCreateInfoFUCHSIA::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39768,54 +37137,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImagePipeSurfaceCreateInfoFUCHSIA::sType; + public: + const vk::StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA; + const void* pNext = nullptr; + vk::ImagePipeSurfaceCreateFlagsFUCHSIA flags; + zx_handle_t imagePipeHandle; }; static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_FUCHSIA*/ - namespace layout - { - struct ImagePlaneMemoryRequirementsInfo - { - protected: - VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT - : planeAspect( planeAspect_ ) - {} - - ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo; - const void* pNext = nullptr; - vk::ImageAspectFlagBits planeAspect; - }; - static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "layout struct and wrapper have different size!" ); - } - - struct ImagePlaneMemoryRequirementsInfo : public layout::ImagePlaneMemoryRequirementsInfo + struct ImagePlaneMemoryRequirementsInfo { VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( vk::ImageAspectFlagBits planeAspect_ = vk::ImageAspectFlagBits::eColor ) VULKAN_HPP_NOEXCEPT - : layout::ImagePlaneMemoryRequirementsInfo( planeAspect_ ) + : planeAspect( planeAspect_ ) {} + vk::ImagePlaneMemoryRequirementsInfo & operator=( vk::ImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImagePlaneMemoryRequirementsInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImagePlaneMemoryRequirementsInfo( rhs ) - {} + { + *this = rhs; + } ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImagePlaneMemoryRequirementsInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -39853,8 +37204,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImagePlaneMemoryRequirementsInfo::sType; + public: + const vk::StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo; + const void* pNext = nullptr; + vk::ImageAspectFlagBits planeAspect; }; static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -39875,12 +37228,12 @@ namespace VULKAN_HPP_NAMESPACE ImageResolve( VkImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ImageResolve& operator=( VkImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -39948,47 +37301,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageSparseMemoryRequirementsInfo2 - { - protected: - VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( vk::Image image_ = vk::Image() ) VULKAN_HPP_NOEXCEPT - : image( image_ ) - {} - - ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2; - const void* pNext = nullptr; - vk::Image image; - }; - static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "layout struct and wrapper have different size!" ); - } - - struct ImageSparseMemoryRequirementsInfo2 : public layout::ImageSparseMemoryRequirementsInfo2 + struct ImageSparseMemoryRequirementsInfo2 { VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( vk::Image image_ = vk::Image() ) VULKAN_HPP_NOEXCEPT - : layout::ImageSparseMemoryRequirementsInfo2( image_ ) + : image( image_ ) {} + vk::ImageSparseMemoryRequirementsInfo2 & operator=( vk::ImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageSparseMemoryRequirementsInfo2 ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageSparseMemoryRequirementsInfo2( rhs ) - {} + { + *this = rhs; + } ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageSparseMemoryRequirementsInfo2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40026,53 +37358,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageSparseMemoryRequirementsInfo2::sType; + public: + const vk::StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2; + const void* pNext = nullptr; + vk::Image image; }; static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageStencilUsageCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfoEXT( vk::ImageUsageFlags stencilUsage_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT - : stencilUsage( stencilUsage_ ) - {} - - ImageStencilUsageCreateInfoEXT( VkImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageStencilUsageCreateInfoEXT; - const void* pNext = nullptr; - vk::ImageUsageFlags stencilUsage; - }; - static_assert( sizeof( ImageStencilUsageCreateInfoEXT ) == sizeof( VkImageStencilUsageCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct ImageStencilUsageCreateInfoEXT : public layout::ImageStencilUsageCreateInfoEXT + struct ImageStencilUsageCreateInfoEXT { VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfoEXT( vk::ImageUsageFlags stencilUsage_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT - : layout::ImageStencilUsageCreateInfoEXT( stencilUsage_ ) + : stencilUsage( stencilUsage_ ) {} + vk::ImageStencilUsageCreateInfoEXT & operator=( vk::ImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageStencilUsageCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageStencilUsageCreateInfoEXT( VkImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageStencilUsageCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageStencilUsageCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40110,53 +37423,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageStencilUsageCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eImageStencilUsageCreateInfoEXT; + const void* pNext = nullptr; + vk::ImageUsageFlags stencilUsage; }; static_assert( sizeof( ImageStencilUsageCreateInfoEXT ) == sizeof( VkImageStencilUsageCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageSwapchainCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR() ) VULKAN_HPP_NOEXCEPT - : swapchain( swapchain_ ) - {} - - ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageSwapchainCreateInfoKHR; - const void* pNext = nullptr; - vk::SwapchainKHR swapchain; - }; - static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImageSwapchainCreateInfoKHR : public layout::ImageSwapchainCreateInfoKHR + struct ImageSwapchainCreateInfoKHR { VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( vk::SwapchainKHR swapchain_ = vk::SwapchainKHR() ) VULKAN_HPP_NOEXCEPT - : layout::ImageSwapchainCreateInfoKHR( swapchain_ ) + : swapchain( swapchain_ ) {} + vk::ImageSwapchainCreateInfoKHR & operator=( vk::ImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageSwapchainCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageSwapchainCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageSwapchainCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40194,53 +37488,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageSwapchainCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImageSwapchainCreateInfoKHR; + const void* pNext = nullptr; + vk::SwapchainKHR swapchain; }; static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageViewASTCDecodeModeEXT - { - protected: - VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( vk::Format decodeMode_ = vk::Format::eUndefined ) VULKAN_HPP_NOEXCEPT - : decodeMode( decodeMode_ ) - {} - - ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageViewAstcDecodeModeEXT; - const void* pNext = nullptr; - vk::Format decodeMode; - }; - static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "layout struct and wrapper have different size!" ); - } - - struct ImageViewASTCDecodeModeEXT : public layout::ImageViewASTCDecodeModeEXT + struct ImageViewASTCDecodeModeEXT { VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( vk::Format decodeMode_ = vk::Format::eUndefined ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewASTCDecodeModeEXT( decodeMode_ ) + : decodeMode( decodeMode_ ) {} + vk::ImageViewASTCDecodeModeEXT & operator=( vk::ImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageViewASTCDecodeModeEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewASTCDecodeModeEXT( rhs ) - {} + { + *this = rhs; + } ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageViewASTCDecodeModeEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40278,56 +37553,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageViewASTCDecodeModeEXT::sType; + public: + const vk::StructureType sType = StructureType::eImageViewAstcDecodeModeEXT; + const void* pNext = nullptr; + vk::Format decodeMode; }; static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageViewCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( vk::ImageViewCreateFlags flags_ = vk::ImageViewCreateFlags(), - vk::Image image_ = vk::Image(), - vk::ImageViewType viewType_ = vk::ImageViewType::e1D, - vk::Format format_ = vk::Format::eUndefined, - vk::ComponentMapping components_ = vk::ComponentMapping(), - vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , image( image_ ) - , viewType( viewType_ ) - , format( format_ ) - , components( components_ ) - , subresourceRange( subresourceRange_ ) - {} - - ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageViewCreateInfo; - const void* pNext = nullptr; - vk::ImageViewCreateFlags flags; - vk::Image image; - vk::ImageViewType viewType; - vk::Format format; - vk::ComponentMapping components; - vk::ImageSubresourceRange subresourceRange; - }; - static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ImageViewCreateInfo : public layout::ImageViewCreateInfo + struct ImageViewCreateInfo { VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( vk::ImageViewCreateFlags flags_ = vk::ImageViewCreateFlags(), vk::Image image_ = vk::Image(), @@ -40335,16 +37569,28 @@ namespace VULKAN_HPP_NAMESPACE vk::Format format_ = vk::Format::eUndefined, vk::ComponentMapping components_ = vk::ComponentMapping(), vk::ImageSubresourceRange subresourceRange_ = vk::ImageSubresourceRange() ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewCreateInfo( flags_, image_, viewType_, format_, components_, subresourceRange_ ) + : flags( flags_ ) + , image( image_ ) + , viewType( viewType_ ) + , format( format_ ) + , components( components_ ) + , subresourceRange( subresourceRange_ ) {} + vk::ImageViewCreateInfo & operator=( vk::ImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageViewCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewCreateInfo( rhs ) - {} + { + *this = rhs; + } ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageViewCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40417,61 +37663,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageViewCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eImageViewCreateInfo; + const void* pNext = nullptr; + vk::ImageViewCreateFlags flags; + vk::Image image; + vk::ImageViewType viewType; + vk::Format format; + vk::ComponentMapping components; + vk::ImageSubresourceRange subresourceRange; }; static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageViewHandleInfoNVX - { - protected: - VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( vk::ImageView imageView_ = vk::ImageView(), - vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler, - vk::Sampler sampler_ = vk::Sampler() ) VULKAN_HPP_NOEXCEPT - : imageView( imageView_ ) - , descriptorType( descriptorType_ ) - , sampler( sampler_ ) - {} - - ImageViewHandleInfoNVX( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageViewHandleInfoNVX& operator=( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageViewHandleInfoNVX; - const void* pNext = nullptr; - vk::ImageView imageView; - vk::DescriptorType descriptorType; - vk::Sampler sampler; - }; - static_assert( sizeof( ImageViewHandleInfoNVX ) == sizeof( VkImageViewHandleInfoNVX ), "layout struct and wrapper have different size!" ); - } - - struct ImageViewHandleInfoNVX : public layout::ImageViewHandleInfoNVX + struct ImageViewHandleInfoNVX { VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( vk::ImageView imageView_ = vk::ImageView(), vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler, vk::Sampler sampler_ = vk::Sampler() ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewHandleInfoNVX( imageView_, descriptorType_, sampler_ ) + : imageView( imageView_ ) + , descriptorType( descriptorType_ ) + , sampler( sampler_ ) {} + vk::ImageViewHandleInfoNVX & operator=( vk::ImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageViewHandleInfoNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageViewHandleInfoNVX( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewHandleInfoNVX( rhs ) - {} + { + *this = rhs; + } ImageViewHandleInfoNVX& operator=( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageViewHandleInfoNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40523,53 +37751,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageViewHandleInfoNVX::sType; + public: + const vk::StructureType sType = StructureType::eImageViewHandleInfoNVX; + const void* pNext = nullptr; + vk::ImageView imageView; + vk::DescriptorType descriptorType; + vk::Sampler sampler; }; static_assert( sizeof( ImageViewHandleInfoNVX ) == sizeof( VkImageViewHandleInfoNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImageViewUsageCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( vk::ImageUsageFlags usage_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT - : usage( usage_ ) - {} - - ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImageViewUsageCreateInfo; - const void* pNext = nullptr; - vk::ImageUsageFlags usage; - }; - static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ImageViewUsageCreateInfo : public layout::ImageViewUsageCreateInfo + struct ImageViewUsageCreateInfo { VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( vk::ImageUsageFlags usage_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewUsageCreateInfo( usage_ ) + : usage( usage_ ) {} + vk::ImageViewUsageCreateInfo & operator=( vk::ImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImageViewUsageCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImageViewUsageCreateInfo( rhs ) - {} + { + *this = rhs; + } ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImageViewUsageCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40607,55 +37818,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImageViewUsageCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eImageViewUsageCreateInfo; + const void* pNext = nullptr; + vk::ImageUsageFlags usage; }; static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_ANDROID_KHR - namespace layout - { - struct ImportAndroidHardwareBufferInfoANDROID - { - protected: - VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr ) VULKAN_HPP_NOEXCEPT - : buffer( buffer_ ) - {} - - ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID; - const void* pNext = nullptr; - struct AHardwareBuffer* buffer; - }; - static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "layout struct and wrapper have different size!" ); - } - - struct ImportAndroidHardwareBufferInfoANDROID : public layout::ImportAndroidHardwareBufferInfoANDROID + struct ImportAndroidHardwareBufferInfoANDROID { VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImportAndroidHardwareBufferInfoANDROID( buffer_ ) + : buffer( buffer_ ) {} + vk::ImportAndroidHardwareBufferInfoANDROID & operator=( vk::ImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportAndroidHardwareBufferInfoANDROID ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportAndroidHardwareBufferInfoANDROID( rhs ) - {} + { + *this = rhs; + } ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportAndroidHardwareBufferInfoANDROID::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40693,66 +37885,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportAndroidHardwareBufferInfoANDROID::sType; + public: + const vk::StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID; + const void* pNext = nullptr; + struct AHardwareBuffer* buffer; }; static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - namespace layout - { - struct ImportFenceFdInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( vk::Fence fence_ = vk::Fence(), - vk::FenceImportFlags flags_ = vk::FenceImportFlags(), - vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd, - int fd_ = 0 ) VULKAN_HPP_NOEXCEPT - : fence( fence_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , fd( fd_ ) - {} - - ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportFenceFdInfoKHR; - const void* pNext = nullptr; - vk::Fence fence; - vk::FenceImportFlags flags; - vk::ExternalFenceHandleTypeFlagBits handleType; - int fd; - }; - static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImportFenceFdInfoKHR : public layout::ImportFenceFdInfoKHR + struct ImportFenceFdInfoKHR { VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( vk::Fence fence_ = vk::Fence(), vk::FenceImportFlags flags_ = vk::FenceImportFlags(), vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd, int fd_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ImportFenceFdInfoKHR( fence_, flags_, handleType_, fd_ ) + : fence( fence_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , fd( fd_ ) {} + vk::ImportFenceFdInfoKHR & operator=( vk::ImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportFenceFdInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportFenceFdInfoKHR( rhs ) - {} + { + *this = rhs; + } ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportFenceFdInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40811,71 +37978,47 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportFenceFdInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImportFenceFdInfoKHR; + const void* pNext = nullptr; + vk::Fence fence; + vk::FenceImportFlags flags; + vk::ExternalFenceHandleTypeFlagBits handleType; + int fd; }; static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ImportFenceWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(), - vk::FenceImportFlags flags_ = vk::FenceImportFlags(), - vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd, - HANDLE handle_ = 0, - LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : fence( fence_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , handle( handle_ ) - , name( name_ ) - {} - - ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR; - const void* pNext = nullptr; - vk::Fence fence; - vk::FenceImportFlags flags; - vk::ExternalFenceHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; - }; - static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImportFenceWin32HandleInfoKHR : public layout::ImportFenceWin32HandleInfoKHR + struct ImportFenceWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( vk::Fence fence_ = vk::Fence(), vk::FenceImportFlags flags_ = vk::FenceImportFlags(), vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImportFenceWin32HandleInfoKHR( fence_, flags_, handleType_, handle_, name_ ) + : fence( fence_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , handle( handle_ ) + , name( name_ ) {} + vk::ImportFenceWin32HandleInfoKHR & operator=( vk::ImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportFenceWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportFenceWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportFenceWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -40941,58 +38084,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportFenceWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR; + const void* pNext = nullptr; + vk::Fence fence; + vk::FenceImportFlags flags; + vk::ExternalFenceHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; }; static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct ImportMemoryFdInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - int fd_ = 0 ) VULKAN_HPP_NOEXCEPT - : handleType( handleType_ ) - , fd( fd_ ) - {} - - ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportMemoryFdInfoKHR; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlagBits handleType; - int fd; - }; - static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImportMemoryFdInfoKHR : public layout::ImportMemoryFdInfoKHR + struct ImportMemoryFdInfoKHR { VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, int fd_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryFdInfoKHR( handleType_, fd_ ) + : handleType( handleType_ ) + , fd( fd_ ) {} + vk::ImportMemoryFdInfoKHR & operator=( vk::ImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportMemoryFdInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryFdInfoKHR( rhs ) - {} + { + *this = rhs; + } ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportMemoryFdInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41037,57 +38163,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportMemoryFdInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImportMemoryFdInfoKHR; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlagBits handleType; + int fd; }; static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ImportMemoryHostPointerInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - void* pHostPointer_ = nullptr ) VULKAN_HPP_NOEXCEPT - : handleType( handleType_ ) - , pHostPointer( pHostPointer_ ) - {} - - ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlagBits handleType; - void* pHostPointer; - }; - static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct ImportMemoryHostPointerInfoEXT : public layout::ImportMemoryHostPointerInfoEXT + struct ImportMemoryHostPointerInfoEXT { VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, void* pHostPointer_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryHostPointerInfoEXT( handleType_, pHostPointer_ ) + : handleType( handleType_ ) + , pHostPointer( pHostPointer_ ) {} + vk::ImportMemoryHostPointerInfoEXT & operator=( vk::ImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportMemoryHostPointerInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryHostPointerInfoEXT( rhs ) - {} + { + *this = rhs; + } ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportMemoryHostPointerInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41132,63 +38238,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportMemoryHostPointerInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlagBits handleType; + void* pHostPointer; }; static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ImportMemoryWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - HANDLE handle_ = 0, - LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : handleType( handleType_ ) - , handle( handle_ ) - , name( name_ ) - {} - - ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; - }; - static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImportMemoryWin32HandleInfoKHR : public layout::ImportMemoryWin32HandleInfoKHR + struct ImportMemoryWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryWin32HandleInfoKHR( handleType_, handle_, name_ ) + : handleType( handleType_ ) + , handle( handle_ ) + , name( name_ ) {} + vk::ImportMemoryWin32HandleInfoKHR & operator=( vk::ImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportMemoryWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportMemoryWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41240,8 +38324,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportMemoryWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; }; static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -41249,51 +38337,28 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ImportMemoryWin32HandleInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleType_ = vk::ExternalMemoryHandleTypeFlagsNV(), - HANDLE handle_ = 0 ) VULKAN_HPP_NOEXCEPT - : handleType( handleType_ ) - , handle( handle_ ) - {} - - ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlagsNV handleType; - HANDLE handle; - }; - static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct ImportMemoryWin32HandleInfoNV : public layout::ImportMemoryWin32HandleInfoNV + struct ImportMemoryWin32HandleInfoNV { VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( vk::ExternalMemoryHandleTypeFlagsNV handleType_ = vk::ExternalMemoryHandleTypeFlagsNV(), HANDLE handle_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryWin32HandleInfoNV( handleType_, handle_ ) + : handleType( handleType_ ) + , handle( handle_ ) {} + vk::ImportMemoryWin32HandleInfoNV & operator=( vk::ImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportMemoryWin32HandleInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportMemoryWin32HandleInfoNV( rhs ) - {} + { + *this = rhs; + } ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportMemoryWin32HandleInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41338,66 +38403,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportMemoryWin32HandleInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlagsNV handleType; + HANDLE handle; }; static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct ImportSemaphoreFdInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), - vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(), - vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, - int fd_ = 0 ) VULKAN_HPP_NOEXCEPT - : semaphore( semaphore_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , fd( fd_ ) - {} - - ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportSemaphoreFdInfoKHR; - const void* pNext = nullptr; - vk::Semaphore semaphore; - vk::SemaphoreImportFlags flags; - vk::ExternalSemaphoreHandleTypeFlagBits handleType; - int fd; - }; - static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImportSemaphoreFdInfoKHR : public layout::ImportSemaphoreFdInfoKHR + struct ImportSemaphoreFdInfoKHR { VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(), vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, int fd_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ImportSemaphoreFdInfoKHR( semaphore_, flags_, handleType_, fd_ ) + : semaphore( semaphore_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , fd( fd_ ) {} + vk::ImportSemaphoreFdInfoKHR & operator=( vk::ImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportSemaphoreFdInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportSemaphoreFdInfoKHR( rhs ) - {} + { + *this = rhs; + } ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportSemaphoreFdInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41456,71 +38497,47 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportSemaphoreFdInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImportSemaphoreFdInfoKHR; + const void* pNext = nullptr; + vk::Semaphore semaphore; + vk::SemaphoreImportFlags flags; + vk::ExternalSemaphoreHandleTypeFlagBits handleType; + int fd; }; static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct ImportSemaphoreWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), - vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(), - vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, - HANDLE handle_ = 0, - LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : semaphore( semaphore_ ) - , flags( flags_ ) - , handleType( handleType_ ) - , handle( handle_ ) - , name( name_ ) - {} - - ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR; - const void* pNext = nullptr; - vk::Semaphore semaphore; - vk::SemaphoreImportFlags flags; - vk::ExternalSemaphoreHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; - }; - static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct ImportSemaphoreWin32HandleInfoKHR : public layout::ImportSemaphoreWin32HandleInfoKHR + struct ImportSemaphoreWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), vk::SemaphoreImportFlags flags_ = vk::SemaphoreImportFlags(), vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ImportSemaphoreWin32HandleInfoKHR( semaphore_, flags_, handleType_, handle_, name_ ) + : semaphore( semaphore_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , handle( handle_ ) + , name( name_ ) {} + vk::ImportSemaphoreWin32HandleInfoKHR & operator=( vk::ImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ImportSemaphoreWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ImportSemaphoreWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ImportSemaphoreWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41586,8 +38603,14 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ImportSemaphoreWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR; + const void* pNext = nullptr; + vk::Semaphore semaphore; + vk::SemaphoreImportFlags flags; + vk::ExternalSemaphoreHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; }; static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -41607,12 +38630,12 @@ namespace VULKAN_HPP_NAMESPACE IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -41672,59 +38695,32 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct IndirectCommandsLayoutCreateInfoNVX - { - protected: - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNVX( vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics, - vk::IndirectCommandsLayoutUsageFlagsNVX flags_ = vk::IndirectCommandsLayoutUsageFlagsNVX(), - uint32_t tokenCount_ = 0, - const vk::IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pipelineBindPoint( pipelineBindPoint_ ) - , flags( flags_ ) - , tokenCount( tokenCount_ ) - , pTokens( pTokens_ ) - {} - - IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX; - const void* pNext = nullptr; - vk::PipelineBindPoint pipelineBindPoint; - vk::IndirectCommandsLayoutUsageFlagsNVX flags; - uint32_t tokenCount; - const vk::IndirectCommandsLayoutTokenNVX* pTokens; - }; - static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "layout struct and wrapper have different size!" ); - } - - struct IndirectCommandsLayoutCreateInfoNVX : public layout::IndirectCommandsLayoutCreateInfoNVX + struct IndirectCommandsLayoutCreateInfoNVX { VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNVX( vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics, vk::IndirectCommandsLayoutUsageFlagsNVX flags_ = vk::IndirectCommandsLayoutUsageFlagsNVX(), uint32_t tokenCount_ = 0, const vk::IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::IndirectCommandsLayoutCreateInfoNVX( pipelineBindPoint_, flags_, tokenCount_, pTokens_ ) + : pipelineBindPoint( pipelineBindPoint_ ) + , flags( flags_ ) + , tokenCount( tokenCount_ ) + , pTokens( pTokens_ ) {} + vk::IndirectCommandsLayoutCreateInfoNVX & operator=( vk::IndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::IndirectCommandsLayoutCreateInfoNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::IndirectCommandsLayoutCreateInfoNVX( rhs ) - {} + { + *this = rhs; + } IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::IndirectCommandsLayoutCreateInfoNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41783,53 +38779,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::IndirectCommandsLayoutCreateInfoNVX::sType; + public: + const vk::StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX; + const void* pNext = nullptr; + vk::PipelineBindPoint pipelineBindPoint; + vk::IndirectCommandsLayoutUsageFlagsNVX flags; + uint32_t tokenCount; + const vk::IndirectCommandsLayoutTokenNVX* pTokens; }; static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct InitializePerformanceApiInfoINTEL - { - protected: - VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pUserData( pUserData_ ) - {} - - InitializePerformanceApiInfoINTEL( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - InitializePerformanceApiInfoINTEL& operator=( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eInitializePerformanceApiInfoINTEL; - const void* pNext = nullptr; - void* pUserData; - }; - static_assert( sizeof( InitializePerformanceApiInfoINTEL ) == sizeof( VkInitializePerformanceApiInfoINTEL ), "layout struct and wrapper have different size!" ); - } - - struct InitializePerformanceApiInfoINTEL : public layout::InitializePerformanceApiInfoINTEL + struct InitializePerformanceApiInfoINTEL { VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( void* pUserData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::InitializePerformanceApiInfoINTEL( pUserData_ ) + : pUserData( pUserData_ ) {} + vk::InitializePerformanceApiInfoINTEL & operator=( vk::InitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::InitializePerformanceApiInfoINTEL ) - sizeof( vk::StructureType ) ); + return *this; + } + InitializePerformanceApiInfoINTEL( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::InitializePerformanceApiInfoINTEL( rhs ) - {} + { + *this = rhs; + } InitializePerformanceApiInfoINTEL& operator=( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::InitializePerformanceApiInfoINTEL::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -41867,8 +38847,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::InitializePerformanceApiInfoINTEL::sType; + public: + const vk::StructureType sType = StructureType::eInitializePerformanceApiInfoINTEL; + const void* pNext = nullptr; + void* pUserData; }; static_assert( sizeof( InitializePerformanceApiInfoINTEL ) == sizeof( VkInitializePerformanceApiInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -41885,12 +38867,12 @@ namespace VULKAN_HPP_NAMESPACE InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } InputAttachmentAspectReference& operator=( VkInputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -41942,50 +38924,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct InstanceCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR InstanceCreateInfo( vk::InstanceCreateFlags flags_ = vk::InstanceCreateFlags(), - const vk::ApplicationInfo* pApplicationInfo_ = nullptr, - uint32_t enabledLayerCount_ = 0, - const char* const* ppEnabledLayerNames_ = nullptr, - uint32_t enabledExtensionCount_ = 0, - const char* const* ppEnabledExtensionNames_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pApplicationInfo( pApplicationInfo_ ) - , enabledLayerCount( enabledLayerCount_ ) - , ppEnabledLayerNames( ppEnabledLayerNames_ ) - , enabledExtensionCount( enabledExtensionCount_ ) - , ppEnabledExtensionNames( ppEnabledExtensionNames_ ) - {} - - InstanceCreateInfo( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eInstanceCreateInfo; - const void* pNext = nullptr; - vk::InstanceCreateFlags flags; - const vk::ApplicationInfo* pApplicationInfo; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; - }; - static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct InstanceCreateInfo : public layout::InstanceCreateInfo + struct InstanceCreateInfo { VULKAN_HPP_CONSTEXPR InstanceCreateInfo( vk::InstanceCreateFlags flags_ = vk::InstanceCreateFlags(), const vk::ApplicationInfo* pApplicationInfo_ = nullptr, @@ -41993,16 +38932,28 @@ namespace VULKAN_HPP_NAMESPACE const char* const* ppEnabledLayerNames_ = nullptr, uint32_t enabledExtensionCount_ = 0, const char* const* ppEnabledExtensionNames_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::InstanceCreateInfo( flags_, pApplicationInfo_, enabledLayerCount_, ppEnabledLayerNames_, enabledExtensionCount_, ppEnabledExtensionNames_ ) + : flags( flags_ ) + , pApplicationInfo( pApplicationInfo_ ) + , enabledLayerCount( enabledLayerCount_ ) + , ppEnabledLayerNames( ppEnabledLayerNames_ ) + , enabledExtensionCount( enabledExtensionCount_ ) + , ppEnabledExtensionNames( ppEnabledExtensionNames_ ) {} + vk::InstanceCreateInfo & operator=( vk::InstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::InstanceCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + InstanceCreateInfo( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::InstanceCreateInfo( rhs ) - {} + { + *this = rhs; + } InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::InstanceCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42075,25 +39026,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::InstanceCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eInstanceCreateInfo; + const void* pNext = nullptr; + vk::InstanceCreateFlags flags; + const vk::ApplicationInfo* pApplicationInfo; + uint32_t enabledLayerCount; + 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::value, "struct wrapper is not a standard layout!" ); struct LayerProperties { - LayerProperties() VULKAN_HPP_NOEXCEPT - {} + LayerProperties( std::array const& layerName_ = { { 0 } }, + uint32_t specVersion_ = 0, + uint32_t implementationVersion_ = 0, + std::array const& description_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT + : layerName{} + , specVersion( specVersion_ ) + , implementationVersion( implementationVersion_ ) + , description{} + { + vk::ConstExpressionArrayCopy::copy( layerName, layerName_ ); + vk::ConstExpressionArrayCopy::copy( description, description_ ); + } LayerProperties( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } LayerProperties& operator=( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -42131,51 +39099,28 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_MACOS_MVK - namespace layout - { - struct MacOSSurfaceCreateInfoMVK - { - protected: - VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( vk::MacOSSurfaceCreateFlagsMVK flags_ = vk::MacOSSurfaceCreateFlagsMVK(), - const void* pView_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pView( pView_ ) - {} - - MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK; - const void* pNext = nullptr; - vk::MacOSSurfaceCreateFlagsMVK flags; - const void* pView; - }; - static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "layout struct and wrapper have different size!" ); - } - - struct MacOSSurfaceCreateInfoMVK : public layout::MacOSSurfaceCreateInfoMVK + struct MacOSSurfaceCreateInfoMVK { VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( vk::MacOSSurfaceCreateFlagsMVK flags_ = vk::MacOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::MacOSSurfaceCreateInfoMVK( flags_, pView_ ) + : flags( flags_ ) + , pView( pView_ ) {} + vk::MacOSSurfaceCreateInfoMVK & operator=( vk::MacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MacOSSurfaceCreateInfoMVK ) - sizeof( vk::StructureType ) ); + return *this; + } + MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MacOSSurfaceCreateInfoMVK( rhs ) - {} + { + *this = rhs; + } MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MacOSSurfaceCreateInfoMVK::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42220,62 +39165,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MacOSSurfaceCreateInfoMVK::sType; + public: + const vk::StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK; + const void* pNext = nullptr; + vk::MacOSSurfaceCreateFlagsMVK flags; + const void* pView; }; static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_MACOS_MVK*/ - namespace layout - { - struct MappedMemoryRange - { - protected: - VULKAN_HPP_CONSTEXPR MappedMemoryRange( vk::DeviceMemory memory_ = vk::DeviceMemory(), - vk::DeviceSize offset_ = 0, - vk::DeviceSize size_ = 0 ) VULKAN_HPP_NOEXCEPT - : memory( memory_ ) - , offset( offset_ ) - , size( size_ ) - {} - - MappedMemoryRange( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMappedMemoryRange; - const void* pNext = nullptr; - vk::DeviceMemory memory; - vk::DeviceSize offset; - vk::DeviceSize size; - }; - static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "layout struct and wrapper have different size!" ); - } - - struct MappedMemoryRange : public layout::MappedMemoryRange + struct MappedMemoryRange { VULKAN_HPP_CONSTEXPR MappedMemoryRange( vk::DeviceMemory memory_ = vk::DeviceMemory(), vk::DeviceSize offset_ = 0, vk::DeviceSize size_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::MappedMemoryRange( memory_, offset_, size_ ) + : memory( memory_ ) + , offset( offset_ ) + , size( size_ ) {} + vk::MappedMemoryRange & operator=( vk::MappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MappedMemoryRange ) - sizeof( vk::StructureType ) ); + return *this; + } + MappedMemoryRange( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MappedMemoryRange( rhs ) - {} + { + *this = rhs; + } MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MappedMemoryRange::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42327,57 +39250,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MappedMemoryRange::sType; + public: + const vk::StructureType sType = StructureType::eMappedMemoryRange; + const void* pNext = nullptr; + vk::DeviceMemory memory; + vk::DeviceSize offset; + vk::DeviceSize size; }; static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct MemoryAllocateFlagsInfo - { - protected: - VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( vk::MemoryAllocateFlags flags_ = vk::MemoryAllocateFlags(), - uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , deviceMask( deviceMask_ ) - {} - - MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryAllocateFlagsInfo; - const void* pNext = nullptr; - vk::MemoryAllocateFlags flags; - uint32_t deviceMask; - }; - static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "layout struct and wrapper have different size!" ); - } - - struct MemoryAllocateFlagsInfo : public layout::MemoryAllocateFlagsInfo + struct MemoryAllocateFlagsInfo { VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( vk::MemoryAllocateFlags flags_ = vk::MemoryAllocateFlags(), uint32_t deviceMask_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::MemoryAllocateFlagsInfo( flags_, deviceMask_ ) + : flags( flags_ ) + , deviceMask( deviceMask_ ) {} + vk::MemoryAllocateFlagsInfo & operator=( vk::MemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryAllocateFlagsInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryAllocateFlagsInfo( rhs ) - {} + { + *this = rhs; + } MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryAllocateFlagsInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42422,57 +39326,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryAllocateFlagsInfo::sType; + public: + const vk::StructureType sType = StructureType::eMemoryAllocateFlagsInfo; + const void* pNext = nullptr; + vk::MemoryAllocateFlags flags; + uint32_t deviceMask; }; static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct MemoryAllocateInfo - { - protected: - VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( vk::DeviceSize allocationSize_ = 0, - uint32_t memoryTypeIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : allocationSize( allocationSize_ ) - , memoryTypeIndex( memoryTypeIndex_ ) - {} - - MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryAllocateInfo; - const void* pNext = nullptr; - vk::DeviceSize allocationSize; - uint32_t memoryTypeIndex; - }; - static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "layout struct and wrapper have different size!" ); - } - - struct MemoryAllocateInfo : public layout::MemoryAllocateInfo + struct MemoryAllocateInfo { VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( vk::DeviceSize allocationSize_ = 0, uint32_t memoryTypeIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::MemoryAllocateInfo( allocationSize_, memoryTypeIndex_ ) + : allocationSize( allocationSize_ ) + , memoryTypeIndex( memoryTypeIndex_ ) {} + vk::MemoryAllocateInfo & operator=( vk::MemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryAllocateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryAllocateInfo( rhs ) - {} + { + *this = rhs; + } MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryAllocateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42517,57 +39401,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryAllocateInfo::sType; + public: + const vk::StructureType sType = StructureType::eMemoryAllocateInfo; + const void* pNext = nullptr; + vk::DeviceSize allocationSize; + uint32_t memoryTypeIndex; }; static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct MemoryBarrier - { - protected: - VULKAN_HPP_CONSTEXPR MemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(), - vk::AccessFlags dstAccessMask_ = vk::AccessFlags() ) VULKAN_HPP_NOEXCEPT - : srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - {} - - MemoryBarrier( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryBarrier& operator=( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryBarrier; - const void* pNext = nullptr; - vk::AccessFlags srcAccessMask; - vk::AccessFlags dstAccessMask; - }; - static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "layout struct and wrapper have different size!" ); - } - - struct MemoryBarrier : public layout::MemoryBarrier + struct MemoryBarrier { VULKAN_HPP_CONSTEXPR MemoryBarrier( vk::AccessFlags srcAccessMask_ = vk::AccessFlags(), vk::AccessFlags dstAccessMask_ = vk::AccessFlags() ) VULKAN_HPP_NOEXCEPT - : layout::MemoryBarrier( srcAccessMask_, dstAccessMask_ ) + : srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) {} + vk::MemoryBarrier & operator=( vk::MemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryBarrier ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryBarrier( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryBarrier( rhs ) - {} + { + *this = rhs; + } MemoryBarrier& operator=( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryBarrier::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42612,57 +39476,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryBarrier::sType; + public: + const vk::StructureType sType = StructureType::eMemoryBarrier; + const void* pNext = nullptr; + vk::AccessFlags srcAccessMask; + vk::AccessFlags dstAccessMask; }; static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct MemoryDedicatedAllocateInfo - { - protected: - VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( vk::Image image_ = vk::Image(), - vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : image( image_ ) - , buffer( buffer_ ) - {} - - MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryDedicatedAllocateInfo; - const void* pNext = nullptr; - vk::Image image; - vk::Buffer buffer; - }; - static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "layout struct and wrapper have different size!" ); - } - - struct MemoryDedicatedAllocateInfo : public layout::MemoryDedicatedAllocateInfo + struct MemoryDedicatedAllocateInfo { VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( vk::Image image_ = vk::Image(), vk::Buffer buffer_ = vk::Buffer() ) VULKAN_HPP_NOEXCEPT - : layout::MemoryDedicatedAllocateInfo( image_, buffer_ ) + : image( image_ ) + , buffer( buffer_ ) {} + vk::MemoryDedicatedAllocateInfo & operator=( vk::MemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryDedicatedAllocateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryDedicatedAllocateInfo( rhs ) - {} + { + *this = rhs; + } MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryDedicatedAllocateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42707,53 +39551,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryDedicatedAllocateInfo::sType; + public: + const vk::StructureType sType = StructureType::eMemoryDedicatedAllocateInfo; + const void* pNext = nullptr; + vk::Image image; + vk::Buffer buffer; }; static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct MemoryDedicatedRequirements { - struct MemoryDedicatedRequirements - { - protected: - MemoryDedicatedRequirements() VULKAN_HPP_NOEXCEPT - {} - - MemoryDedicatedRequirements( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryDedicatedRequirements& operator=( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryDedicatedRequirements; - void* pNext = nullptr; - vk::Bool32 prefersDedicatedAllocation; - vk::Bool32 requiresDedicatedAllocation; - }; - static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "layout struct and wrapper have different size!" ); - } - - struct MemoryDedicatedRequirements : public layout::MemoryDedicatedRequirements - { - MemoryDedicatedRequirements() VULKAN_HPP_NOEXCEPT - : layout::MemoryDedicatedRequirements() + MemoryDedicatedRequirements( vk::Bool32 prefersDedicatedAllocation_ = 0, + vk::Bool32 requiresDedicatedAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT + : prefersDedicatedAllocation( prefersDedicatedAllocation_ ) + , requiresDedicatedAllocation( requiresDedicatedAllocation_ ) {} + vk::MemoryDedicatedRequirements & operator=( vk::MemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryDedicatedRequirements ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryDedicatedRequirements( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryDedicatedRequirements( rhs ) - {} + { + *this = rhs; + } MemoryDedicatedRequirements& operator=( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryDedicatedRequirements::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42780,52 +39608,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryDedicatedRequirements::sType; + public: + const vk::StructureType sType = StructureType::eMemoryDedicatedRequirements; + void* pNext = nullptr; + vk::Bool32 prefersDedicatedAllocation; + vk::Bool32 requiresDedicatedAllocation; }; static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct MemoryFdPropertiesKHR { - struct MemoryFdPropertiesKHR - { - protected: - MemoryFdPropertiesKHR() VULKAN_HPP_NOEXCEPT - {} - - MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryFdPropertiesKHR& operator=( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryFdPropertiesKHR; - void* pNext = nullptr; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct MemoryFdPropertiesKHR : public layout::MemoryFdPropertiesKHR - { - MemoryFdPropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::MemoryFdPropertiesKHR() + MemoryFdPropertiesKHR( uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT + : memoryTypeBits( memoryTypeBits_ ) {} + vk::MemoryFdPropertiesKHR & operator=( vk::MemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryFdPropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryFdPropertiesKHR( rhs ) - {} + { + *this = rhs; + } MemoryFdPropertiesKHR& operator=( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryFdPropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42851,55 +39662,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryFdPropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::eMemoryFdPropertiesKHR; + void* pNext = nullptr; + uint32_t memoryTypeBits; }; static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_ANDROID_KHR - namespace layout - { - struct MemoryGetAndroidHardwareBufferInfoANDROID - { - protected: - VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( vk::DeviceMemory memory_ = vk::DeviceMemory() ) VULKAN_HPP_NOEXCEPT - : memory( memory_ ) - {} - - MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID; - const void* pNext = nullptr; - vk::DeviceMemory memory; - }; - static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "layout struct and wrapper have different size!" ); - } - - struct MemoryGetAndroidHardwareBufferInfoANDROID : public layout::MemoryGetAndroidHardwareBufferInfoANDROID + struct MemoryGetAndroidHardwareBufferInfoANDROID { VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( vk::DeviceMemory memory_ = vk::DeviceMemory() ) VULKAN_HPP_NOEXCEPT - : layout::MemoryGetAndroidHardwareBufferInfoANDROID( memory_ ) + : memory( memory_ ) {} + vk::MemoryGetAndroidHardwareBufferInfoANDROID & operator=( vk::MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryGetAndroidHardwareBufferInfoANDROID ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryGetAndroidHardwareBufferInfoANDROID( rhs ) - {} + { + *this = rhs; + } MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryGetAndroidHardwareBufferInfoANDROID::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -42937,58 +39729,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryGetAndroidHardwareBufferInfoANDROID::sType; + public: + const vk::StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID; + const void* pNext = nullptr; + vk::DeviceMemory memory; }; static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - namespace layout - { - struct MemoryGetFdInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(), - vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : memory( memory_ ) - , handleType( handleType_ ) - {} - - MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryGetFdInfoKHR; - const void* pNext = nullptr; - vk::DeviceMemory memory; - vk::ExternalMemoryHandleTypeFlagBits handleType; - }; - static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct MemoryGetFdInfoKHR : public layout::MemoryGetFdInfoKHR + struct MemoryGetFdInfoKHR { VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(), vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::MemoryGetFdInfoKHR( memory_, handleType_ ) + : memory( memory_ ) + , handleType( handleType_ ) {} + vk::MemoryGetFdInfoKHR & operator=( vk::MemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryGetFdInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryGetFdInfoKHR( rhs ) - {} + { + *this = rhs; + } MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryGetFdInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43033,59 +39804,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryGetFdInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eMemoryGetFdInfoKHR; + const void* pNext = nullptr; + vk::DeviceMemory memory; + vk::ExternalMemoryHandleTypeFlagBits handleType; }; static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct MemoryGetWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(), - vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : memory( memory_ ) - , handleType( handleType_ ) - {} - - MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR; - const void* pNext = nullptr; - vk::DeviceMemory memory; - vk::ExternalMemoryHandleTypeFlagBits handleType; - }; - static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct MemoryGetWin32HandleInfoKHR : public layout::MemoryGetWin32HandleInfoKHR + struct MemoryGetWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( vk::DeviceMemory memory_ = vk::DeviceMemory(), vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::MemoryGetWin32HandleInfoKHR( memory_, handleType_ ) + : memory( memory_ ) + , handleType( handleType_ ) {} + vk::MemoryGetWin32HandleInfoKHR & operator=( vk::MemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryGetWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryGetWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryGetWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43130,8 +39881,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryGetWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR; + const void* pNext = nullptr; + vk::DeviceMemory memory; + vk::ExternalMemoryHandleTypeFlagBits handleType; }; static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -43139,17 +39893,20 @@ namespace VULKAN_HPP_NAMESPACE struct MemoryHeap { - MemoryHeap() VULKAN_HPP_NOEXCEPT + MemoryHeap( vk::DeviceSize size_ = 0, + vk::MemoryHeapFlags flags_ = vk::MemoryHeapFlags() ) VULKAN_HPP_NOEXCEPT + : size( size_ ) + , flags( flags_ ) {} MemoryHeap( VkMemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } MemoryHeap& operator=( VkMemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -43181,46 +39938,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct MemoryHostPointerPropertiesEXT { - struct MemoryHostPointerPropertiesEXT - { - protected: - MemoryHostPointerPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT; - void* pNext = nullptr; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct MemoryHostPointerPropertiesEXT : public layout::MemoryHostPointerPropertiesEXT - { - MemoryHostPointerPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::MemoryHostPointerPropertiesEXT() + MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT + : memoryTypeBits( memoryTypeBits_ ) {} + vk::MemoryHostPointerPropertiesEXT & operator=( vk::MemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryHostPointerPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryHostPointerPropertiesEXT( rhs ) - {} + { + *this = rhs; + } MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryHostPointerPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43246,53 +39983,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryHostPointerPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT; + void* pNext = nullptr; + uint32_t memoryTypeBits; }; static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct MemoryPriorityAllocateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( float priority_ = 0 ) VULKAN_HPP_NOEXCEPT - : priority( priority_ ) - {} - - MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryPriorityAllocateInfoEXT& operator=( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT; - const void* pNext = nullptr; - float priority; - }; - static_assert( sizeof( MemoryPriorityAllocateInfoEXT ) == sizeof( VkMemoryPriorityAllocateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct MemoryPriorityAllocateInfoEXT : public layout::MemoryPriorityAllocateInfoEXT + struct MemoryPriorityAllocateInfoEXT { VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( float priority_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::MemoryPriorityAllocateInfoEXT( priority_ ) + : priority( priority_ ) {} + vk::MemoryPriorityAllocateInfoEXT & operator=( vk::MemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryPriorityAllocateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryPriorityAllocateInfoEXT( rhs ) - {} + { + *this = rhs; + } MemoryPriorityAllocateInfoEXT& operator=( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryPriorityAllocateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43330,25 +40048,32 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryPriorityAllocateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT; + const void* pNext = nullptr; + float priority; }; static_assert( sizeof( MemoryPriorityAllocateInfoEXT ) == sizeof( VkMemoryPriorityAllocateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct MemoryRequirements { - MemoryRequirements() VULKAN_HPP_NOEXCEPT + MemoryRequirements( vk::DeviceSize size_ = 0, + vk::DeviceSize alignment_ = 0, + uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT + : size( size_ ) + , alignment( alignment_ ) + , memoryTypeBits( memoryTypeBits_ ) {} MemoryRequirements( VkMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } MemoryRequirements& operator=( VkMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -43382,46 +40107,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct MemoryRequirements2 { - struct MemoryRequirements2 - { - protected: - MemoryRequirements2() VULKAN_HPP_NOEXCEPT - {} - - MemoryRequirements2( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryRequirements2& operator=( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryRequirements2; - void* pNext = nullptr; - vk::MemoryRequirements memoryRequirements; - }; - static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "layout struct and wrapper have different size!" ); - } - - struct MemoryRequirements2 : public layout::MemoryRequirements2 - { - MemoryRequirements2() VULKAN_HPP_NOEXCEPT - : layout::MemoryRequirements2() + MemoryRequirements2( vk::MemoryRequirements memoryRequirements_ = vk::MemoryRequirements() ) VULKAN_HPP_NOEXCEPT + : memoryRequirements( memoryRequirements_ ) {} + vk::MemoryRequirements2 & operator=( vk::MemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryRequirements2 ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryRequirements2( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryRequirements2( rhs ) - {} + { + *this = rhs; + } MemoryRequirements2& operator=( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryRequirements2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43447,25 +40152,30 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryRequirements2::sType; + public: + const vk::StructureType sType = StructureType::eMemoryRequirements2; + void* pNext = nullptr; + vk::MemoryRequirements memoryRequirements; }; static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct MemoryType { - MemoryType() VULKAN_HPP_NOEXCEPT + MemoryType( vk::MemoryPropertyFlags propertyFlags_ = vk::MemoryPropertyFlags(), + uint32_t heapIndex_ = 0 ) VULKAN_HPP_NOEXCEPT + : propertyFlags( propertyFlags_ ) + , heapIndex( heapIndex_ ) {} MemoryType( VkMemoryType const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } MemoryType& operator=( VkMemoryType const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -43499,46 +40209,26 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout + struct MemoryWin32HandlePropertiesKHR { - struct MemoryWin32HandlePropertiesKHR - { - protected: - MemoryWin32HandlePropertiesKHR() VULKAN_HPP_NOEXCEPT - {} - - MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MemoryWin32HandlePropertiesKHR& operator=( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR; - void* pNext = nullptr; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct MemoryWin32HandlePropertiesKHR : public layout::MemoryWin32HandlePropertiesKHR - { - MemoryWin32HandlePropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::MemoryWin32HandlePropertiesKHR() + MemoryWin32HandlePropertiesKHR( uint32_t memoryTypeBits_ = 0 ) VULKAN_HPP_NOEXCEPT + : memoryTypeBits( memoryTypeBits_ ) {} + vk::MemoryWin32HandlePropertiesKHR & operator=( vk::MemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MemoryWin32HandlePropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MemoryWin32HandlePropertiesKHR( rhs ) - {} + { + *this = rhs; + } MemoryWin32HandlePropertiesKHR& operator=( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MemoryWin32HandlePropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43564,8 +40254,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MemoryWin32HandlePropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR; + void* pNext = nullptr; + uint32_t memoryTypeBits; }; static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -43573,51 +40265,28 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_METAL_EXT - namespace layout - { - struct MetalSurfaceCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( vk::MetalSurfaceCreateFlagsEXT flags_ = vk::MetalSurfaceCreateFlagsEXT(), - const CAMetalLayer* pLayer_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pLayer( pLayer_ ) - {} - - MetalSurfaceCreateInfoEXT( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MetalSurfaceCreateInfoEXT& operator=( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMetalSurfaceCreateInfoEXT; - const void* pNext = nullptr; - vk::MetalSurfaceCreateFlagsEXT flags; - const CAMetalLayer* pLayer; - }; - static_assert( sizeof( MetalSurfaceCreateInfoEXT ) == sizeof( VkMetalSurfaceCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct MetalSurfaceCreateInfoEXT : public layout::MetalSurfaceCreateInfoEXT + struct MetalSurfaceCreateInfoEXT { VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( vk::MetalSurfaceCreateFlagsEXT flags_ = vk::MetalSurfaceCreateFlagsEXT(), const CAMetalLayer* pLayer_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::MetalSurfaceCreateInfoEXT( flags_, pLayer_ ) + : flags( flags_ ) + , pLayer( pLayer_ ) {} + vk::MetalSurfaceCreateInfoEXT & operator=( vk::MetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MetalSurfaceCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + MetalSurfaceCreateInfoEXT( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MetalSurfaceCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } MetalSurfaceCreateInfoEXT& operator=( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MetalSurfaceCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43662,53 +40331,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MetalSurfaceCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eMetalSurfaceCreateInfoEXT; + const void* pNext = nullptr; + vk::MetalSurfaceCreateFlagsEXT flags; + const CAMetalLayer* pLayer; }; static_assert( sizeof( MetalSurfaceCreateInfoEXT ) == sizeof( VkMetalSurfaceCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_METAL_EXT*/ - namespace layout + struct MultisamplePropertiesEXT { - struct MultisamplePropertiesEXT - { - protected: - MultisamplePropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - MultisamplePropertiesEXT& operator=( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eMultisamplePropertiesEXT; - void* pNext = nullptr; - vk::Extent2D maxSampleLocationGridSize; - }; - static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct MultisamplePropertiesEXT : public layout::MultisamplePropertiesEXT - { - MultisamplePropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::MultisamplePropertiesEXT() + MultisamplePropertiesEXT( vk::Extent2D maxSampleLocationGridSize_ = vk::Extent2D() ) VULKAN_HPP_NOEXCEPT + : maxSampleLocationGridSize( maxSampleLocationGridSize_ ) {} + vk::MultisamplePropertiesEXT & operator=( vk::MultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::MultisamplePropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::MultisamplePropertiesEXT( rhs ) - {} + { + *this = rhs; + } MultisamplePropertiesEXT& operator=( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::MultisamplePropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43734,65 +40386,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::MultisamplePropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::eMultisamplePropertiesEXT; + void* pNext = nullptr; + vk::Extent2D maxSampleLocationGridSize; }; static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ObjectTableCreateInfoNVX - { - protected: - VULKAN_HPP_CONSTEXPR ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0, - const vk::ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr, - const uint32_t* pObjectEntryCounts_ = nullptr, - const vk::ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr, - uint32_t maxUniformBuffersPerDescriptor_ = 0, - uint32_t maxStorageBuffersPerDescriptor_ = 0, - uint32_t maxStorageImagesPerDescriptor_ = 0, - uint32_t maxSampledImagesPerDescriptor_ = 0, - uint32_t maxPipelineLayouts_ = 0 ) VULKAN_HPP_NOEXCEPT - : objectCount( objectCount_ ) - , pObjectEntryTypes( pObjectEntryTypes_ ) - , pObjectEntryCounts( pObjectEntryCounts_ ) - , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ ) - , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ ) - , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ ) - , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ ) - , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ ) - , maxPipelineLayouts( maxPipelineLayouts_ ) - {} - - ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eObjectTableCreateInfoNVX; - const void* pNext = nullptr; - uint32_t objectCount; - const vk::ObjectEntryTypeNVX* pObjectEntryTypes; - const uint32_t* pObjectEntryCounts; - const vk::ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; - uint32_t maxUniformBuffersPerDescriptor; - uint32_t maxStorageBuffersPerDescriptor; - uint32_t maxStorageImagesPerDescriptor; - uint32_t maxSampledImagesPerDescriptor; - uint32_t maxPipelineLayouts; - }; - static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "layout struct and wrapper have different size!" ); - } - - struct ObjectTableCreateInfoNVX : public layout::ObjectTableCreateInfoNVX + struct ObjectTableCreateInfoNVX { VULKAN_HPP_CONSTEXPR ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0, const vk::ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr, @@ -43803,16 +40405,31 @@ namespace VULKAN_HPP_NAMESPACE uint32_t maxStorageImagesPerDescriptor_ = 0, uint32_t maxSampledImagesPerDescriptor_ = 0, uint32_t maxPipelineLayouts_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ObjectTableCreateInfoNVX( objectCount_, pObjectEntryTypes_, pObjectEntryCounts_, pObjectEntryUsageFlags_, maxUniformBuffersPerDescriptor_, maxStorageBuffersPerDescriptor_, maxStorageImagesPerDescriptor_, maxSampledImagesPerDescriptor_, maxPipelineLayouts_ ) + : objectCount( objectCount_ ) + , pObjectEntryTypes( pObjectEntryTypes_ ) + , pObjectEntryCounts( pObjectEntryCounts_ ) + , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ ) + , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ ) + , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ ) + , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ ) + , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ ) + , maxPipelineLayouts( maxPipelineLayouts_ ) {} + vk::ObjectTableCreateInfoNVX & operator=( vk::ObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ObjectTableCreateInfoNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ObjectTableCreateInfoNVX( rhs ) - {} + { + *this = rhs; + } ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ObjectTableCreateInfoNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -43906,8 +40523,18 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ObjectTableCreateInfoNVX::sType; + public: + const vk::StructureType sType = StructureType::eObjectTableCreateInfoNVX; + const void* pNext = nullptr; + uint32_t objectCount; + const vk::ObjectEntryTypeNVX* pObjectEntryTypes; + const uint32_t* pObjectEntryCounts; + const vk::ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags; + uint32_t maxUniformBuffersPerDescriptor; + uint32_t maxStorageBuffersPerDescriptor; + uint32_t maxStorageImagesPerDescriptor; + uint32_t maxSampledImagesPerDescriptor; + uint32_t maxPipelineLayouts; }; static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -43922,12 +40549,12 @@ namespace VULKAN_HPP_NAMESPACE ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -43994,12 +40621,12 @@ namespace VULKAN_HPP_NAMESPACE ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -44082,12 +40709,12 @@ namespace VULKAN_HPP_NAMESPACE ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -44166,12 +40793,12 @@ namespace VULKAN_HPP_NAMESPACE ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -44246,12 +40873,12 @@ namespace VULKAN_HPP_NAMESPACE ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -44330,12 +40957,12 @@ namespace VULKAN_HPP_NAMESPACE ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -44389,17 +41016,26 @@ namespace VULKAN_HPP_NAMESPACE struct PastPresentationTimingGOOGLE { - PastPresentationTimingGOOGLE() VULKAN_HPP_NOEXCEPT + PastPresentationTimingGOOGLE( uint32_t presentID_ = 0, + uint64_t desiredPresentTime_ = 0, + uint64_t actualPresentTime_ = 0, + uint64_t earliestPresentTime_ = 0, + uint64_t presentMargin_ = 0 ) VULKAN_HPP_NOEXCEPT + : presentID( presentID_ ) + , desiredPresentTime( desiredPresentTime_ ) + , actualPresentTime( actualPresentTime_ ) + , earliestPresentTime( earliestPresentTime_ ) + , presentMargin( presentMargin_ ) {} PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PastPresentationTimingGOOGLE& operator=( VkPastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -44437,47 +41073,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PerformanceConfigurationAcquireInfoINTEL - { - protected: - VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( vk::PerformanceConfigurationTypeINTEL type_ = vk::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated ) VULKAN_HPP_NOEXCEPT - : type( type_ ) - {} - - PerformanceConfigurationAcquireInfoINTEL( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PerformanceConfigurationAcquireInfoINTEL& operator=( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePerformanceConfigurationAcquireInfoINTEL; - const void* pNext = nullptr; - vk::PerformanceConfigurationTypeINTEL type; - }; - static_assert( sizeof( PerformanceConfigurationAcquireInfoINTEL ) == sizeof( VkPerformanceConfigurationAcquireInfoINTEL ), "layout struct and wrapper have different size!" ); - } - - struct PerformanceConfigurationAcquireInfoINTEL : public layout::PerformanceConfigurationAcquireInfoINTEL + struct PerformanceConfigurationAcquireInfoINTEL { VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( vk::PerformanceConfigurationTypeINTEL type_ = vk::PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceConfigurationAcquireInfoINTEL( type_ ) + : type( type_ ) {} + vk::PerformanceConfigurationAcquireInfoINTEL & operator=( vk::PerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceConfigurationAcquireInfoINTEL ) - sizeof( vk::StructureType ) ); + return *this; + } + PerformanceConfigurationAcquireInfoINTEL( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceConfigurationAcquireInfoINTEL( rhs ) - {} + { + *this = rhs; + } PerformanceConfigurationAcquireInfoINTEL& operator=( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PerformanceConfigurationAcquireInfoINTEL::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -44515,53 +41130,255 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PerformanceConfigurationAcquireInfoINTEL::sType; + public: + const vk::StructureType sType = StructureType::ePerformanceConfigurationAcquireInfoINTEL; + const void* pNext = nullptr; + vk::PerformanceConfigurationTypeINTEL type; }; static_assert( sizeof( PerformanceConfigurationAcquireInfoINTEL ) == sizeof( VkPerformanceConfigurationAcquireInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PerformanceCounterDescriptionKHR { - struct PerformanceMarkerInfoINTEL + PerformanceCounterDescriptionKHR( vk::PerformanceCounterDescriptionFlagsKHR flags_ = vk::PerformanceCounterDescriptionFlagsKHR(), + std::array const& name_ = { { 0 } }, + std::array const& category_ = { { 0 } }, + std::array const& description_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT + : flags( flags_ ) + , name{} + , category{} + , description{} { - protected: - VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( uint64_t marker_ = 0 ) VULKAN_HPP_NOEXCEPT - : marker( marker_ ) - {} + vk::ConstExpressionArrayCopy::copy( name, name_ ); + vk::ConstExpressionArrayCopy::copy( category, category_ ); + vk::ConstExpressionArrayCopy::copy( description, description_ ); + } - PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } + vk::PerformanceCounterDescriptionKHR & operator=( vk::PerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceCounterDescriptionKHR ) - sizeof( vk::StructureType ) ); + return *this; + } - PerformanceMarkerInfoINTEL& operator=( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } + PerformanceCounterDescriptionKHR( VkPerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } - public: - vk::StructureType sType = StructureType::ePerformanceMarkerInfoINTEL; - const void* pNext = nullptr; - uint64_t marker; - }; - static_assert( sizeof( PerformanceMarkerInfoINTEL ) == sizeof( VkPerformanceMarkerInfoINTEL ), "layout struct and wrapper have different size!" ); - } + PerformanceCounterDescriptionKHR& operator=( VkPerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast(&rhs); + return *this; + } - struct PerformanceMarkerInfoINTEL : public layout::PerformanceMarkerInfoINTEL + operator VkPerformanceCounterDescriptionKHR const&() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceCounterDescriptionKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( PerformanceCounterDescriptionKHR const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( memcmp( name, rhs.name, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 ) + && ( memcmp( category, rhs.category, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 ) + && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 ); + } + + bool operator!=( PerformanceCounterDescriptionKHR const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + const vk::StructureType sType = StructureType::ePerformanceCounterDescriptionKHR; + const void* pNext = nullptr; + vk::PerformanceCounterDescriptionFlagsKHR flags; + char name[VK_MAX_DESCRIPTION_SIZE]; + char category[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + }; + static_assert( sizeof( PerformanceCounterDescriptionKHR ) == sizeof( VkPerformanceCounterDescriptionKHR ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + struct PerformanceCounterKHR + { + PerformanceCounterKHR( vk::PerformanceCounterUnitKHR unit_ = vk::PerformanceCounterUnitKHR::eGeneric, + vk::PerformanceCounterScopeKHR scope_ = vk::PerformanceCounterScopeKHR::eVkQueryScopeCommandBuffer, + vk::PerformanceCounterStorageKHR storage_ = vk::PerformanceCounterStorageKHR::eInt32, + std::array const& uuid_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT + : unit( unit_ ) + , scope( scope_ ) + , storage( storage_ ) + , uuid{} + { + vk::ConstExpressionArrayCopy::copy( uuid, uuid_ ); + } + + vk::PerformanceCounterKHR & operator=( vk::PerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceCounterKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + + PerformanceCounterKHR( VkPerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } + + PerformanceCounterKHR& operator=( VkPerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast(&rhs); + return *this; + } + + operator VkPerformanceCounterKHR const&() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceCounterKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( PerformanceCounterKHR const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( unit == rhs.unit ) + && ( scope == rhs.scope ) + && ( storage == rhs.storage ) + && ( memcmp( uuid, rhs.uuid, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ); + } + + bool operator!=( PerformanceCounterKHR const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + const vk::StructureType sType = StructureType::ePerformanceCounterKHR; + const void* pNext = nullptr; + vk::PerformanceCounterUnitKHR unit; + vk::PerformanceCounterScopeKHR scope; + vk::PerformanceCounterStorageKHR storage; + uint8_t uuid[VK_UUID_SIZE]; + }; + static_assert( sizeof( PerformanceCounterKHR ) == sizeof( VkPerformanceCounterKHR ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + union PerformanceCounterResultKHR + { + PerformanceCounterResultKHR( int32_t int32_ = 0 ) + { + int32 = int32_; + } + + PerformanceCounterResultKHR( int64_t int64_ ) + { + int64 = int64_; + } + + PerformanceCounterResultKHR( uint32_t uint32_ ) + { + uint32 = uint32_; + } + + PerformanceCounterResultKHR( uint64_t uint64_ ) + { + uint64 = uint64_; + } + + PerformanceCounterResultKHR( float float32_ ) + { + float32 = float32_; + } + + PerformanceCounterResultKHR( double float64_ ) + { + float64 = float64_; + } + + PerformanceCounterResultKHR & setInt32( int32_t int32_ ) VULKAN_HPP_NOEXCEPT + { + int32 = int32_; + return *this; + } + + PerformanceCounterResultKHR & setInt64( int64_t int64_ ) VULKAN_HPP_NOEXCEPT + { + int64 = int64_; + return *this; + } + + PerformanceCounterResultKHR & setUint32( uint32_t uint32_ ) VULKAN_HPP_NOEXCEPT + { + uint32 = uint32_; + return *this; + } + + PerformanceCounterResultKHR & setUint64( uint64_t uint64_ ) VULKAN_HPP_NOEXCEPT + { + uint64 = uint64_; + return *this; + } + + PerformanceCounterResultKHR & setFloat32( float float32_ ) VULKAN_HPP_NOEXCEPT + { + float32 = float32_; + return *this; + } + + PerformanceCounterResultKHR & setFloat64( double float64_ ) VULKAN_HPP_NOEXCEPT + { + float64 = float64_; + return *this; + } + operator VkPerformanceCounterResultKHR const&() const + { + return *reinterpret_cast(this); + } + + operator VkPerformanceCounterResultKHR &() + { + return *reinterpret_cast(this); + } + + int32_t int32; + int64_t int64; + uint32_t uint32; + uint64_t uint64; + float float32; + double float64; + }; + + struct PerformanceMarkerInfoINTEL { VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( uint64_t marker_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceMarkerInfoINTEL( marker_ ) + : marker( marker_ ) {} + vk::PerformanceMarkerInfoINTEL & operator=( vk::PerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceMarkerInfoINTEL ) - sizeof( vk::StructureType ) ); + return *this; + } + PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceMarkerInfoINTEL( rhs ) - {} + { + *this = rhs; + } PerformanceMarkerInfoINTEL& operator=( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PerformanceMarkerInfoINTEL::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -44599,61 +41416,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PerformanceMarkerInfoINTEL::sType; + public: + const vk::StructureType sType = StructureType::ePerformanceMarkerInfoINTEL; + const void* pNext = nullptr; + uint64_t marker; }; static_assert( sizeof( PerformanceMarkerInfoINTEL ) == sizeof( VkPerformanceMarkerInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PerformanceOverrideInfoINTEL - { - protected: - VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( vk::PerformanceOverrideTypeINTEL type_ = vk::PerformanceOverrideTypeINTEL::eNullHardware, - vk::Bool32 enable_ = 0, - uint64_t parameter_ = 0 ) VULKAN_HPP_NOEXCEPT - : type( type_ ) - , enable( enable_ ) - , parameter( parameter_ ) - {} - - PerformanceOverrideInfoINTEL( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PerformanceOverrideInfoINTEL& operator=( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePerformanceOverrideInfoINTEL; - const void* pNext = nullptr; - vk::PerformanceOverrideTypeINTEL type; - vk::Bool32 enable; - uint64_t parameter; - }; - static_assert( sizeof( PerformanceOverrideInfoINTEL ) == sizeof( VkPerformanceOverrideInfoINTEL ), "layout struct and wrapper have different size!" ); - } - - struct PerformanceOverrideInfoINTEL : public layout::PerformanceOverrideInfoINTEL + struct PerformanceOverrideInfoINTEL { VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( vk::PerformanceOverrideTypeINTEL type_ = vk::PerformanceOverrideTypeINTEL::eNullHardware, vk::Bool32 enable_ = 0, uint64_t parameter_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceOverrideInfoINTEL( type_, enable_, parameter_ ) + : type( type_ ) + , enable( enable_ ) + , parameter( parameter_ ) {} + vk::PerformanceOverrideInfoINTEL & operator=( vk::PerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceOverrideInfoINTEL ) - sizeof( vk::StructureType ) ); + return *this; + } + PerformanceOverrideInfoINTEL( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceOverrideInfoINTEL( rhs ) - {} + { + *this = rhs; + } PerformanceOverrideInfoINTEL& operator=( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PerformanceOverrideInfoINTEL::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -44705,53 +41499,101 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PerformanceOverrideInfoINTEL::sType; + public: + const vk::StructureType sType = StructureType::ePerformanceOverrideInfoINTEL; + const void* pNext = nullptr; + vk::PerformanceOverrideTypeINTEL type; + vk::Bool32 enable; + uint64_t parameter; }; static_assert( sizeof( PerformanceOverrideInfoINTEL ) == sizeof( VkPerformanceOverrideInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PerformanceQuerySubmitInfoKHR { - struct PerformanceStreamMarkerInfoINTEL + VULKAN_HPP_CONSTEXPR PerformanceQuerySubmitInfoKHR( uint32_t counterPassIndex_ = 0 ) VULKAN_HPP_NOEXCEPT + : counterPassIndex( counterPassIndex_ ) + {} + + vk::PerformanceQuerySubmitInfoKHR & operator=( vk::PerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - protected: - VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = 0 ) VULKAN_HPP_NOEXCEPT - : marker( marker_ ) - {} + memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceQuerySubmitInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } - PerformanceStreamMarkerInfoINTEL( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } + PerformanceQuerySubmitInfoKHR( VkPerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } - PerformanceStreamMarkerInfoINTEL& operator=( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } + PerformanceQuerySubmitInfoKHR& operator=( VkPerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast(&rhs); + return *this; + } - public: - vk::StructureType sType = StructureType::ePerformanceStreamMarkerInfoINTEL; - const void* pNext = nullptr; - uint32_t marker; - }; - static_assert( sizeof( PerformanceStreamMarkerInfoINTEL ) == sizeof( VkPerformanceStreamMarkerInfoINTEL ), "layout struct and wrapper have different size!" ); - } + PerformanceQuerySubmitInfoKHR & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } - struct PerformanceStreamMarkerInfoINTEL : public layout::PerformanceStreamMarkerInfoINTEL + PerformanceQuerySubmitInfoKHR & setCounterPassIndex( uint32_t counterPassIndex_ ) VULKAN_HPP_NOEXCEPT + { + counterPassIndex = counterPassIndex_; + return *this; + } + + operator VkPerformanceQuerySubmitInfoKHR const&() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceQuerySubmitInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( PerformanceQuerySubmitInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( counterPassIndex == rhs.counterPassIndex ); + } + + bool operator!=( PerformanceQuerySubmitInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + const vk::StructureType sType = StructureType::ePerformanceQuerySubmitInfoKHR; + const void* pNext = nullptr; + uint32_t counterPassIndex; + }; + static_assert( sizeof( PerformanceQuerySubmitInfoKHR ) == sizeof( VkPerformanceQuerySubmitInfoKHR ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + struct PerformanceStreamMarkerInfoINTEL { VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceStreamMarkerInfoINTEL( marker_ ) + : marker( marker_ ) {} + vk::PerformanceStreamMarkerInfoINTEL & operator=( vk::PerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PerformanceStreamMarkerInfoINTEL ) - sizeof( vk::StructureType ) ); + return *this; + } + PerformanceStreamMarkerInfoINTEL( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PerformanceStreamMarkerInfoINTEL( rhs ) - {} + { + *this = rhs; + } PerformanceStreamMarkerInfoINTEL& operator=( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PerformanceStreamMarkerInfoINTEL::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -44789,8 +41631,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PerformanceStreamMarkerInfoINTEL::sType; + public: + const vk::StructureType sType = StructureType::ePerformanceStreamMarkerInfoINTEL; + const void* pNext = nullptr; + uint32_t marker; }; static_assert( sizeof( PerformanceStreamMarkerInfoINTEL ) == sizeof( VkPerformanceStreamMarkerInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -44881,12 +41725,12 @@ namespace VULKAN_HPP_NAMESPACE PerformanceValueINTEL( VkPerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PerformanceValueINTEL& operator=( VkPerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -44919,59 +41763,32 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PerformanceValueINTEL ) == sizeof( VkPerformanceValueINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDevice16BitStorageFeatures - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( vk::Bool32 storageBuffer16BitAccess_ = 0, - vk::Bool32 uniformAndStorageBuffer16BitAccess_ = 0, - vk::Bool32 storagePushConstant16_ = 0, - vk::Bool32 storageInputOutput16_ = 0 ) VULKAN_HPP_NOEXCEPT - : storageBuffer16BitAccess( storageBuffer16BitAccess_ ) - , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ ) - , storagePushConstant16( storagePushConstant16_ ) - , storageInputOutput16( storageInputOutput16_ ) - {} - - PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDevice16BitStorageFeatures& operator=( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDevice16BitStorageFeatures; - void* pNext = nullptr; - vk::Bool32 storageBuffer16BitAccess; - vk::Bool32 uniformAndStorageBuffer16BitAccess; - vk::Bool32 storagePushConstant16; - vk::Bool32 storageInputOutput16; - }; - static_assert( sizeof( PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDevice16BitStorageFeatures : public layout::PhysicalDevice16BitStorageFeatures + struct PhysicalDevice16BitStorageFeatures { VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( vk::Bool32 storageBuffer16BitAccess_ = 0, vk::Bool32 uniformAndStorageBuffer16BitAccess_ = 0, vk::Bool32 storagePushConstant16_ = 0, vk::Bool32 storageInputOutput16_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevice16BitStorageFeatures( storageBuffer16BitAccess_, uniformAndStorageBuffer16BitAccess_, storagePushConstant16_, storageInputOutput16_ ) + : storageBuffer16BitAccess( storageBuffer16BitAccess_ ) + , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ ) + , storagePushConstant16( storagePushConstant16_ ) + , storageInputOutput16( storageInputOutput16_ ) {} + vk::PhysicalDevice16BitStorageFeatures & operator=( vk::PhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevice16BitStorageFeatures ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevice16BitStorageFeatures( rhs ) - {} + { + *this = rhs; + } PhysicalDevice16BitStorageFeatures& operator=( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDevice16BitStorageFeatures::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45030,61 +41847,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDevice16BitStorageFeatures::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDevice16BitStorageFeatures; + void* pNext = nullptr; + vk::Bool32 storageBuffer16BitAccess; + vk::Bool32 uniformAndStorageBuffer16BitAccess; + vk::Bool32 storagePushConstant16; + vk::Bool32 storageInputOutput16; }; static_assert( sizeof( PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDevice8BitStorageFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeaturesKHR( vk::Bool32 storageBuffer8BitAccess_ = 0, - vk::Bool32 uniformAndStorageBuffer8BitAccess_ = 0, - vk::Bool32 storagePushConstant8_ = 0 ) VULKAN_HPP_NOEXCEPT - : storageBuffer8BitAccess( storageBuffer8BitAccess_ ) - , uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ ) - , storagePushConstant8( storagePushConstant8_ ) - {} - - PhysicalDevice8BitStorageFeaturesKHR( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDevice8BitStorageFeaturesKHR& operator=( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDevice8BitStorageFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 storageBuffer8BitAccess; - vk::Bool32 uniformAndStorageBuffer8BitAccess; - vk::Bool32 storagePushConstant8; - }; - static_assert( sizeof( PhysicalDevice8BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice8BitStorageFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDevice8BitStorageFeaturesKHR : public layout::PhysicalDevice8BitStorageFeaturesKHR + struct PhysicalDevice8BitStorageFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeaturesKHR( vk::Bool32 storageBuffer8BitAccess_ = 0, vk::Bool32 uniformAndStorageBuffer8BitAccess_ = 0, vk::Bool32 storagePushConstant8_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevice8BitStorageFeaturesKHR( storageBuffer8BitAccess_, uniformAndStorageBuffer8BitAccess_, storagePushConstant8_ ) + : storageBuffer8BitAccess( storageBuffer8BitAccess_ ) + , uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ ) + , storagePushConstant8( storagePushConstant8_ ) {} + vk::PhysicalDevice8BitStorageFeaturesKHR & operator=( vk::PhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevice8BitStorageFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDevice8BitStorageFeaturesKHR( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevice8BitStorageFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDevice8BitStorageFeaturesKHR& operator=( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDevice8BitStorageFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45136,53 +41933,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDevice8BitStorageFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDevice8BitStorageFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 storageBuffer8BitAccess; + vk::Bool32 uniformAndStorageBuffer8BitAccess; + vk::Bool32 storagePushConstant8; }; static_assert( sizeof( PhysicalDevice8BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice8BitStorageFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceASTCDecodeFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( vk::Bool32 decodeModeSharedExponent_ = 0 ) VULKAN_HPP_NOEXCEPT - : decodeModeSharedExponent( decodeModeSharedExponent_ ) - {} - - PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 decodeModeSharedExponent; - }; - static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceASTCDecodeFeaturesEXT : public layout::PhysicalDeviceASTCDecodeFeaturesEXT + struct PhysicalDeviceASTCDecodeFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( vk::Bool32 decodeModeSharedExponent_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceASTCDecodeFeaturesEXT( decodeModeSharedExponent_ ) + : decodeModeSharedExponent( decodeModeSharedExponent_ ) {} + vk::PhysicalDeviceASTCDecodeFeaturesEXT & operator=( vk::PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceASTCDecodeFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceASTCDecodeFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceASTCDecodeFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45220,53 +42000,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceASTCDecodeFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 decodeModeSharedExponent; }; static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( vk::Bool32 advancedBlendCoherentOperations_ = 0 ) VULKAN_HPP_NOEXCEPT - : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ ) - {} - - PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 advancedBlendCoherentOperations; - }; - static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT : public layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT + struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( vk::Bool32 advancedBlendCoherentOperations_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT( advancedBlendCoherentOperations_ ) + : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ ) {} + vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT & operator=( vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45304,57 +42065,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceBlendOperationAdvancedFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 advancedBlendCoherentOperations; }; static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { - struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT - { - protected: - PhysicalDeviceBlendOperationAdvancedPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceBlendOperationAdvancedPropertiesEXT( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; - void* pNext = nullptr; - uint32_t advancedBlendMaxColorAttachments; - vk::Bool32 advancedBlendIndependentBlend; - vk::Bool32 advancedBlendNonPremultipliedSrcColor; - vk::Bool32 advancedBlendNonPremultipliedDstColor; - vk::Bool32 advancedBlendCorrelatedOverlap; - vk::Bool32 advancedBlendAllOperations; - }; - static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT : public layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT - { - PhysicalDeviceBlendOperationAdvancedPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT() + PhysicalDeviceBlendOperationAdvancedPropertiesEXT( uint32_t advancedBlendMaxColorAttachments_ = 0, + vk::Bool32 advancedBlendIndependentBlend_ = 0, + vk::Bool32 advancedBlendNonPremultipliedSrcColor_ = 0, + vk::Bool32 advancedBlendNonPremultipliedDstColor_ = 0, + vk::Bool32 advancedBlendCorrelatedOverlap_ = 0, + vk::Bool32 advancedBlendAllOperations_ = 0 ) VULKAN_HPP_NOEXCEPT + : advancedBlendMaxColorAttachments( advancedBlendMaxColorAttachments_ ) + , advancedBlendIndependentBlend( advancedBlendIndependentBlend_ ) + , advancedBlendNonPremultipliedSrcColor( advancedBlendNonPremultipliedSrcColor_ ) + , advancedBlendNonPremultipliedDstColor( advancedBlendNonPremultipliedDstColor_ ) + , advancedBlendCorrelatedOverlap( advancedBlendCorrelatedOverlap_ ) + , advancedBlendAllOperations( advancedBlendAllOperations_ ) {} + vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT & operator=( vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceBlendOperationAdvancedPropertiesEXT( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45385,61 +42133,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceBlendOperationAdvancedPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; + void* pNext = nullptr; + uint32_t advancedBlendMaxColorAttachments; + vk::Bool32 advancedBlendIndependentBlend; + vk::Bool32 advancedBlendNonPremultipliedSrcColor; + vk::Bool32 advancedBlendNonPremultipliedDstColor; + vk::Bool32 advancedBlendCorrelatedOverlap; + vk::Bool32 advancedBlendAllOperations; }; static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceBufferDeviceAddressFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( vk::Bool32 bufferDeviceAddress_ = 0, - vk::Bool32 bufferDeviceAddressCaptureReplay_ = 0, - vk::Bool32 bufferDeviceAddressMultiDevice_ = 0 ) VULKAN_HPP_NOEXCEPT - : bufferDeviceAddress( bufferDeviceAddress_ ) - , bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ ) - , bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ ) - {} - - PhysicalDeviceBufferDeviceAddressFeaturesEXT( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 bufferDeviceAddress; - vk::Bool32 bufferDeviceAddressCaptureReplay; - vk::Bool32 bufferDeviceAddressMultiDevice; - }; - static_assert( sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceBufferDeviceAddressFeaturesEXT : public layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT + struct PhysicalDeviceBufferDeviceAddressFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( vk::Bool32 bufferDeviceAddress_ = 0, vk::Bool32 bufferDeviceAddressCaptureReplay_ = 0, vk::Bool32 bufferDeviceAddressMultiDevice_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT( bufferDeviceAddress_, bufferDeviceAddressCaptureReplay_, bufferDeviceAddressMultiDevice_ ) + : bufferDeviceAddress( bufferDeviceAddress_ ) + , bufferDeviceAddressCaptureReplay( bufferDeviceAddressCaptureReplay_ ) + , bufferDeviceAddressMultiDevice( bufferDeviceAddressMultiDevice_ ) {} + vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT & operator=( vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceBufferDeviceAddressFeaturesEXT( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45491,53 +42221,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceBufferDeviceAddressFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 bufferDeviceAddress; + vk::Bool32 bufferDeviceAddressCaptureReplay; + vk::Bool32 bufferDeviceAddressMultiDevice; }; static_assert( sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceCoherentMemoryFeaturesAMD - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( vk::Bool32 deviceCoherentMemory_ = 0 ) VULKAN_HPP_NOEXCEPT - : deviceCoherentMemory( deviceCoherentMemory_ ) - {} - - PhysicalDeviceCoherentMemoryFeaturesAMD( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceCoherentMemoryFeaturesAMD& operator=( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD; - void* pNext = nullptr; - vk::Bool32 deviceCoherentMemory; - }; - static_assert( sizeof( PhysicalDeviceCoherentMemoryFeaturesAMD ) == sizeof( VkPhysicalDeviceCoherentMemoryFeaturesAMD ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceCoherentMemoryFeaturesAMD : public layout::PhysicalDeviceCoherentMemoryFeaturesAMD + struct PhysicalDeviceCoherentMemoryFeaturesAMD { VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( vk::Bool32 deviceCoherentMemory_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCoherentMemoryFeaturesAMD( deviceCoherentMemory_ ) + : deviceCoherentMemory( deviceCoherentMemory_ ) {} + vk::PhysicalDeviceCoherentMemoryFeaturesAMD & operator=( vk::PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCoherentMemoryFeaturesAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceCoherentMemoryFeaturesAMD( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCoherentMemoryFeaturesAMD( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceCoherentMemoryFeaturesAMD& operator=( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceCoherentMemoryFeaturesAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45575,57 +42288,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceCoherentMemoryFeaturesAMD::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD; + void* pNext = nullptr; + vk::Bool32 deviceCoherentMemory; }; static_assert( sizeof( PhysicalDeviceCoherentMemoryFeaturesAMD ) == sizeof( VkPhysicalDeviceCoherentMemoryFeaturesAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceComputeShaderDerivativesFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesNV( vk::Bool32 computeDerivativeGroupQuads_ = 0, - vk::Bool32 computeDerivativeGroupLinear_ = 0 ) VULKAN_HPP_NOEXCEPT - : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ ) - , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ ) - {} - - PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV; - void* pNext = nullptr; - vk::Bool32 computeDerivativeGroupQuads; - vk::Bool32 computeDerivativeGroupLinear; - }; - static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceComputeShaderDerivativesFeaturesNV : public layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV + struct PhysicalDeviceComputeShaderDerivativesFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesNV( vk::Bool32 computeDerivativeGroupQuads_ = 0, vk::Bool32 computeDerivativeGroupLinear_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV( computeDerivativeGroupQuads_, computeDerivativeGroupLinear_ ) + : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ ) + , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ ) {} + vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV & operator=( vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceComputeShaderDerivativesFeaturesNV( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45670,57 +42362,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceComputeShaderDerivativesFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV; + void* pNext = nullptr; + vk::Bool32 computeDerivativeGroupQuads; + vk::Bool32 computeDerivativeGroupLinear; }; static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceConditionalRenderingFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( vk::Bool32 conditionalRendering_ = 0, - vk::Bool32 inheritedConditionalRendering_ = 0 ) VULKAN_HPP_NOEXCEPT - : conditionalRendering( conditionalRendering_ ) - , inheritedConditionalRendering( inheritedConditionalRendering_ ) - {} - - PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceConditionalRenderingFeaturesEXT& operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 conditionalRendering; - vk::Bool32 inheritedConditionalRendering; - }; - static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceConditionalRenderingFeaturesEXT : public layout::PhysicalDeviceConditionalRenderingFeaturesEXT + struct PhysicalDeviceConditionalRenderingFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( vk::Bool32 conditionalRendering_ = 0, vk::Bool32 inheritedConditionalRendering_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceConditionalRenderingFeaturesEXT( conditionalRendering_, inheritedConditionalRendering_ ) + : conditionalRendering( conditionalRendering_ ) + , inheritedConditionalRendering( inheritedConditionalRendering_ ) {} + vk::PhysicalDeviceConditionalRenderingFeaturesEXT & operator=( vk::PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceConditionalRenderingFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceConditionalRenderingFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceConditionalRenderingFeaturesEXT& operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceConditionalRenderingFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45765,60 +42437,51 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceConditionalRenderingFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 conditionalRendering; + vk::Bool32 inheritedConditionalRendering; }; static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceConservativeRasterizationPropertiesEXT { - struct PhysicalDeviceConservativeRasterizationPropertiesEXT - { - protected: - PhysicalDeviceConservativeRasterizationPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT; - void* pNext = nullptr; - float primitiveOverestimationSize; - float maxExtraPrimitiveOverestimationSize; - float extraPrimitiveOverestimationSizeGranularity; - vk::Bool32 primitiveUnderestimation; - vk::Bool32 conservativePointAndLineRasterization; - vk::Bool32 degenerateTrianglesRasterized; - vk::Bool32 degenerateLinesRasterized; - vk::Bool32 fullyCoveredFragmentShaderInputVariable; - vk::Bool32 conservativeRasterizationPostDepthCoverage; - }; - static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceConservativeRasterizationPropertiesEXT : public layout::PhysicalDeviceConservativeRasterizationPropertiesEXT - { - PhysicalDeviceConservativeRasterizationPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceConservativeRasterizationPropertiesEXT() + PhysicalDeviceConservativeRasterizationPropertiesEXT( float primitiveOverestimationSize_ = 0, + float maxExtraPrimitiveOverestimationSize_ = 0, + float extraPrimitiveOverestimationSizeGranularity_ = 0, + vk::Bool32 primitiveUnderestimation_ = 0, + vk::Bool32 conservativePointAndLineRasterization_ = 0, + vk::Bool32 degenerateTrianglesRasterized_ = 0, + vk::Bool32 degenerateLinesRasterized_ = 0, + vk::Bool32 fullyCoveredFragmentShaderInputVariable_ = 0, + vk::Bool32 conservativeRasterizationPostDepthCoverage_ = 0 ) VULKAN_HPP_NOEXCEPT + : primitiveOverestimationSize( primitiveOverestimationSize_ ) + , maxExtraPrimitiveOverestimationSize( maxExtraPrimitiveOverestimationSize_ ) + , extraPrimitiveOverestimationSizeGranularity( extraPrimitiveOverestimationSizeGranularity_ ) + , primitiveUnderestimation( primitiveUnderestimation_ ) + , conservativePointAndLineRasterization( conservativePointAndLineRasterization_ ) + , degenerateTrianglesRasterized( degenerateTrianglesRasterized_ ) + , degenerateLinesRasterized( degenerateLinesRasterized_ ) + , fullyCoveredFragmentShaderInputVariable( fullyCoveredFragmentShaderInputVariable_ ) + , conservativeRasterizationPostDepthCoverage( conservativeRasterizationPostDepthCoverage_ ) {} + vk::PhysicalDeviceConservativeRasterizationPropertiesEXT & operator=( vk::PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceConservativeRasterizationPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceConservativeRasterizationPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceConservativeRasterizationPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45852,57 +42515,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceConservativeRasterizationPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT; + void* pNext = nullptr; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + vk::Bool32 primitiveUnderestimation; + vk::Bool32 conservativePointAndLineRasterization; + vk::Bool32 degenerateTrianglesRasterized; + vk::Bool32 degenerateLinesRasterized; + vk::Bool32 fullyCoveredFragmentShaderInputVariable; + vk::Bool32 conservativeRasterizationPostDepthCoverage; }; static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceCooperativeMatrixFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( vk::Bool32 cooperativeMatrix_ = 0, - vk::Bool32 cooperativeMatrixRobustBufferAccess_ = 0 ) VULKAN_HPP_NOEXCEPT - : cooperativeMatrix( cooperativeMatrix_ ) - , cooperativeMatrixRobustBufferAccess( cooperativeMatrixRobustBufferAccess_ ) - {} - - PhysicalDeviceCooperativeMatrixFeaturesNV( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceCooperativeMatrixFeaturesNV& operator=( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV; - void* pNext = nullptr; - vk::Bool32 cooperativeMatrix; - vk::Bool32 cooperativeMatrixRobustBufferAccess; - }; - static_assert( sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceCooperativeMatrixFeaturesNV : public layout::PhysicalDeviceCooperativeMatrixFeaturesNV + struct PhysicalDeviceCooperativeMatrixFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( vk::Bool32 cooperativeMatrix_ = 0, vk::Bool32 cooperativeMatrixRobustBufferAccess_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCooperativeMatrixFeaturesNV( cooperativeMatrix_, cooperativeMatrixRobustBufferAccess_ ) + : cooperativeMatrix( cooperativeMatrix_ ) + , cooperativeMatrixRobustBufferAccess( cooperativeMatrixRobustBufferAccess_ ) {} + vk::PhysicalDeviceCooperativeMatrixFeaturesNV & operator=( vk::PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCooperativeMatrixFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceCooperativeMatrixFeaturesNV( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCooperativeMatrixFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceCooperativeMatrixFeaturesNV& operator=( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceCooperativeMatrixFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -45947,52 +42597,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceCooperativeMatrixFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV; + void* pNext = nullptr; + vk::Bool32 cooperativeMatrix; + vk::Bool32 cooperativeMatrixRobustBufferAccess; }; static_assert( sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceCooperativeMatrixPropertiesNV { - struct PhysicalDeviceCooperativeMatrixPropertiesNV - { - protected: - PhysicalDeviceCooperativeMatrixPropertiesNV() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceCooperativeMatrixPropertiesNV& operator=( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV; - void* pNext = nullptr; - vk::ShaderStageFlags cooperativeMatrixSupportedStages; - }; - static_assert( sizeof( PhysicalDeviceCooperativeMatrixPropertiesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceCooperativeMatrixPropertiesNV : public layout::PhysicalDeviceCooperativeMatrixPropertiesNV - { - PhysicalDeviceCooperativeMatrixPropertiesNV() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCooperativeMatrixPropertiesNV() + PhysicalDeviceCooperativeMatrixPropertiesNV( vk::ShaderStageFlags cooperativeMatrixSupportedStages_ = vk::ShaderStageFlags() ) VULKAN_HPP_NOEXCEPT + : cooperativeMatrixSupportedStages( cooperativeMatrixSupportedStages_ ) {} + vk::PhysicalDeviceCooperativeMatrixPropertiesNV & operator=( vk::PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCooperativeMatrixPropertiesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCooperativeMatrixPropertiesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceCooperativeMatrixPropertiesNV& operator=( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceCooperativeMatrixPropertiesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46018,53 +42651,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceCooperativeMatrixPropertiesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV; + void* pNext = nullptr; + vk::ShaderStageFlags cooperativeMatrixSupportedStages; }; static_assert( sizeof( PhysicalDeviceCooperativeMatrixPropertiesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceCornerSampledImageFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( vk::Bool32 cornerSampledImage_ = 0 ) VULKAN_HPP_NOEXCEPT - : cornerSampledImage( cornerSampledImage_ ) - {} - - PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV; - void* pNext = nullptr; - vk::Bool32 cornerSampledImage; - }; - static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceCornerSampledImageFeaturesNV : public layout::PhysicalDeviceCornerSampledImageFeaturesNV + struct PhysicalDeviceCornerSampledImageFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( vk::Bool32 cornerSampledImage_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCornerSampledImageFeaturesNV( cornerSampledImage_ ) + : cornerSampledImage( cornerSampledImage_ ) {} + vk::PhysicalDeviceCornerSampledImageFeaturesNV & operator=( vk::PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCornerSampledImageFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCornerSampledImageFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceCornerSampledImageFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46102,53 +42716,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceCornerSampledImageFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV; + void* pNext = nullptr; + vk::Bool32 cornerSampledImage; }; static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceCoverageReductionModeFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( vk::Bool32 coverageReductionMode_ = 0 ) VULKAN_HPP_NOEXCEPT - : coverageReductionMode( coverageReductionMode_ ) - {} - - PhysicalDeviceCoverageReductionModeFeaturesNV( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceCoverageReductionModeFeaturesNV& operator=( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV; - void* pNext = nullptr; - vk::Bool32 coverageReductionMode; - }; - static_assert( sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) == sizeof( VkPhysicalDeviceCoverageReductionModeFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceCoverageReductionModeFeaturesNV : public layout::PhysicalDeviceCoverageReductionModeFeaturesNV + struct PhysicalDeviceCoverageReductionModeFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( vk::Bool32 coverageReductionMode_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCoverageReductionModeFeaturesNV( coverageReductionMode_ ) + : coverageReductionMode( coverageReductionMode_ ) {} + vk::PhysicalDeviceCoverageReductionModeFeaturesNV & operator=( vk::PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceCoverageReductionModeFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceCoverageReductionModeFeaturesNV( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceCoverageReductionModeFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceCoverageReductionModeFeaturesNV& operator=( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceCoverageReductionModeFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46186,53 +42781,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceCoverageReductionModeFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV; + void* pNext = nullptr; + vk::Bool32 coverageReductionMode; }; static_assert( sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) == sizeof( VkPhysicalDeviceCoverageReductionModeFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( vk::Bool32 dedicatedAllocationImageAliasing_ = 0 ) VULKAN_HPP_NOEXCEPT - : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ ) - {} - - PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; - void* pNext = nullptr; - vk::Bool32 dedicatedAllocationImageAliasing; - }; - static_assert( sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) == sizeof( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV : public layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV + struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( vk::Bool32 dedicatedAllocationImageAliasing_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( dedicatedAllocationImageAliasing_ ) + : dedicatedAllocationImageAliasing( dedicatedAllocationImageAliasing_ ) {} + vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & operator=( vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46270,53 +42846,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + void* pNext = nullptr; + vk::Bool32 dedicatedAllocationImageAliasing; }; static_assert( sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) == sizeof( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceDepthClipEnableFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( vk::Bool32 depthClipEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : depthClipEnable( depthClipEnable_ ) - {} - - PhysicalDeviceDepthClipEnableFeaturesEXT( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceDepthClipEnableFeaturesEXT& operator=( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 depthClipEnable; - }; - static_assert( sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipEnableFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceDepthClipEnableFeaturesEXT : public layout::PhysicalDeviceDepthClipEnableFeaturesEXT + struct PhysicalDeviceDepthClipEnableFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( vk::Bool32 depthClipEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDepthClipEnableFeaturesEXT( depthClipEnable_ ) + : depthClipEnable( depthClipEnable_ ) {} + vk::PhysicalDeviceDepthClipEnableFeaturesEXT & operator=( vk::PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDepthClipEnableFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceDepthClipEnableFeaturesEXT( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDepthClipEnableFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceDepthClipEnableFeaturesEXT& operator=( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceDepthClipEnableFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46354,55 +42911,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceDepthClipEnableFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 depthClipEnable; }; static_assert( sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipEnableFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceDepthStencilResolvePropertiesKHR { - struct PhysicalDeviceDepthStencilResolvePropertiesKHR - { - protected: - PhysicalDeviceDepthStencilResolvePropertiesKHR() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceDepthStencilResolvePropertiesKHR( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceDepthStencilResolvePropertiesKHR& operator=( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR; - void* pNext = nullptr; - vk::ResolveModeFlagsKHR supportedDepthResolveModes; - vk::ResolveModeFlagsKHR supportedStencilResolveModes; - vk::Bool32 independentResolveNone; - vk::Bool32 independentResolve; - }; - static_assert( sizeof( PhysicalDeviceDepthStencilResolvePropertiesKHR ) == sizeof( VkPhysicalDeviceDepthStencilResolvePropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceDepthStencilResolvePropertiesKHR : public layout::PhysicalDeviceDepthStencilResolvePropertiesKHR - { - PhysicalDeviceDepthStencilResolvePropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDepthStencilResolvePropertiesKHR() + PhysicalDeviceDepthStencilResolvePropertiesKHR( vk::ResolveModeFlagsKHR supportedDepthResolveModes_ = vk::ResolveModeFlagsKHR(), + vk::ResolveModeFlagsKHR supportedStencilResolveModes_ = vk::ResolveModeFlagsKHR(), + vk::Bool32 independentResolveNone_ = 0, + vk::Bool32 independentResolve_ = 0 ) VULKAN_HPP_NOEXCEPT + : supportedDepthResolveModes( supportedDepthResolveModes_ ) + , supportedStencilResolveModes( supportedStencilResolveModes_ ) + , independentResolveNone( independentResolveNone_ ) + , independentResolve( independentResolve_ ) {} + vk::PhysicalDeviceDepthStencilResolvePropertiesKHR & operator=( vk::PhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDepthStencilResolvePropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceDepthStencilResolvePropertiesKHR( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDepthStencilResolvePropertiesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceDepthStencilResolvePropertiesKHR& operator=( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceDepthStencilResolvePropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46431,98 +42973,18 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceDepthStencilResolvePropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceDepthStencilResolvePropertiesKHR; + void* pNext = nullptr; + vk::ResolveModeFlagsKHR supportedDepthResolveModes; + vk::ResolveModeFlagsKHR supportedStencilResolveModes; + vk::Bool32 independentResolveNone; + vk::Bool32 independentResolve; }; static_assert( sizeof( PhysicalDeviceDepthStencilResolvePropertiesKHR ) == sizeof( VkPhysicalDeviceDepthStencilResolvePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceDescriptorIndexingFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeaturesEXT( vk::Bool32 shaderInputAttachmentArrayDynamicIndexing_ = 0, - vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = 0, - vk::Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = 0, - vk::Bool32 shaderUniformBufferArrayNonUniformIndexing_ = 0, - vk::Bool32 shaderSampledImageArrayNonUniformIndexing_ = 0, - vk::Bool32 shaderStorageBufferArrayNonUniformIndexing_ = 0, - vk::Bool32 shaderStorageImageArrayNonUniformIndexing_ = 0, - vk::Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = 0, - vk::Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = 0, - vk::Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = 0, - vk::Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = 0, - vk::Bool32 descriptorBindingSampledImageUpdateAfterBind_ = 0, - vk::Bool32 descriptorBindingStorageImageUpdateAfterBind_ = 0, - vk::Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = 0, - vk::Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = 0, - vk::Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = 0, - vk::Bool32 descriptorBindingUpdateUnusedWhilePending_ = 0, - vk::Bool32 descriptorBindingPartiallyBound_ = 0, - vk::Bool32 descriptorBindingVariableDescriptorCount_ = 0, - vk::Bool32 runtimeDescriptorArray_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderInputAttachmentArrayDynamicIndexing( shaderInputAttachmentArrayDynamicIndexing_ ) - , shaderUniformTexelBufferArrayDynamicIndexing( shaderUniformTexelBufferArrayDynamicIndexing_ ) - , shaderStorageTexelBufferArrayDynamicIndexing( shaderStorageTexelBufferArrayDynamicIndexing_ ) - , shaderUniformBufferArrayNonUniformIndexing( shaderUniformBufferArrayNonUniformIndexing_ ) - , shaderSampledImageArrayNonUniformIndexing( shaderSampledImageArrayNonUniformIndexing_ ) - , shaderStorageBufferArrayNonUniformIndexing( shaderStorageBufferArrayNonUniformIndexing_ ) - , shaderStorageImageArrayNonUniformIndexing( shaderStorageImageArrayNonUniformIndexing_ ) - , shaderInputAttachmentArrayNonUniformIndexing( shaderInputAttachmentArrayNonUniformIndexing_ ) - , shaderUniformTexelBufferArrayNonUniformIndexing( shaderUniformTexelBufferArrayNonUniformIndexing_ ) - , shaderStorageTexelBufferArrayNonUniformIndexing( shaderStorageTexelBufferArrayNonUniformIndexing_ ) - , descriptorBindingUniformBufferUpdateAfterBind( descriptorBindingUniformBufferUpdateAfterBind_ ) - , descriptorBindingSampledImageUpdateAfterBind( descriptorBindingSampledImageUpdateAfterBind_ ) - , descriptorBindingStorageImageUpdateAfterBind( descriptorBindingStorageImageUpdateAfterBind_ ) - , descriptorBindingStorageBufferUpdateAfterBind( descriptorBindingStorageBufferUpdateAfterBind_ ) - , descriptorBindingUniformTexelBufferUpdateAfterBind( descriptorBindingUniformTexelBufferUpdateAfterBind_ ) - , descriptorBindingStorageTexelBufferUpdateAfterBind( descriptorBindingStorageTexelBufferUpdateAfterBind_ ) - , descriptorBindingUpdateUnusedWhilePending( descriptorBindingUpdateUnusedWhilePending_ ) - , descriptorBindingPartiallyBound( descriptorBindingPartiallyBound_ ) - , descriptorBindingVariableDescriptorCount( descriptorBindingVariableDescriptorCount_ ) - , runtimeDescriptorArray( runtimeDescriptorArray_ ) - {} - - PhysicalDeviceDescriptorIndexingFeaturesEXT( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceDescriptorIndexingFeaturesEXT& operator=( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 shaderInputAttachmentArrayDynamicIndexing; - vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing; - vk::Bool32 shaderStorageTexelBufferArrayDynamicIndexing; - vk::Bool32 shaderUniformBufferArrayNonUniformIndexing; - vk::Bool32 shaderSampledImageArrayNonUniformIndexing; - vk::Bool32 shaderStorageBufferArrayNonUniformIndexing; - vk::Bool32 shaderStorageImageArrayNonUniformIndexing; - vk::Bool32 shaderInputAttachmentArrayNonUniformIndexing; - vk::Bool32 shaderUniformTexelBufferArrayNonUniformIndexing; - vk::Bool32 shaderStorageTexelBufferArrayNonUniformIndexing; - vk::Bool32 descriptorBindingUniformBufferUpdateAfterBind; - vk::Bool32 descriptorBindingSampledImageUpdateAfterBind; - vk::Bool32 descriptorBindingStorageImageUpdateAfterBind; - vk::Bool32 descriptorBindingStorageBufferUpdateAfterBind; - vk::Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind; - vk::Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind; - vk::Bool32 descriptorBindingUpdateUnusedWhilePending; - vk::Bool32 descriptorBindingPartiallyBound; - vk::Bool32 descriptorBindingVariableDescriptorCount; - vk::Bool32 runtimeDescriptorArray; - }; - static_assert( sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceDescriptorIndexingFeaturesEXT : public layout::PhysicalDeviceDescriptorIndexingFeaturesEXT + struct PhysicalDeviceDescriptorIndexingFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeaturesEXT( vk::Bool32 shaderInputAttachmentArrayDynamicIndexing_ = 0, vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = 0, @@ -46544,16 +43006,42 @@ namespace VULKAN_HPP_NAMESPACE vk::Bool32 descriptorBindingPartiallyBound_ = 0, vk::Bool32 descriptorBindingVariableDescriptorCount_ = 0, vk::Bool32 runtimeDescriptorArray_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDescriptorIndexingFeaturesEXT( shaderInputAttachmentArrayDynamicIndexing_, shaderUniformTexelBufferArrayDynamicIndexing_, shaderStorageTexelBufferArrayDynamicIndexing_, shaderUniformBufferArrayNonUniformIndexing_, shaderSampledImageArrayNonUniformIndexing_, shaderStorageBufferArrayNonUniformIndexing_, shaderStorageImageArrayNonUniformIndexing_, shaderInputAttachmentArrayNonUniformIndexing_, shaderUniformTexelBufferArrayNonUniformIndexing_, shaderStorageTexelBufferArrayNonUniformIndexing_, descriptorBindingUniformBufferUpdateAfterBind_, descriptorBindingSampledImageUpdateAfterBind_, descriptorBindingStorageImageUpdateAfterBind_, descriptorBindingStorageBufferUpdateAfterBind_, descriptorBindingUniformTexelBufferUpdateAfterBind_, descriptorBindingStorageTexelBufferUpdateAfterBind_, descriptorBindingUpdateUnusedWhilePending_, descriptorBindingPartiallyBound_, descriptorBindingVariableDescriptorCount_, runtimeDescriptorArray_ ) + : shaderInputAttachmentArrayDynamicIndexing( shaderInputAttachmentArrayDynamicIndexing_ ) + , shaderUniformTexelBufferArrayDynamicIndexing( shaderUniformTexelBufferArrayDynamicIndexing_ ) + , shaderStorageTexelBufferArrayDynamicIndexing( shaderStorageTexelBufferArrayDynamicIndexing_ ) + , shaderUniformBufferArrayNonUniformIndexing( shaderUniformBufferArrayNonUniformIndexing_ ) + , shaderSampledImageArrayNonUniformIndexing( shaderSampledImageArrayNonUniformIndexing_ ) + , shaderStorageBufferArrayNonUniformIndexing( shaderStorageBufferArrayNonUniformIndexing_ ) + , shaderStorageImageArrayNonUniformIndexing( shaderStorageImageArrayNonUniformIndexing_ ) + , shaderInputAttachmentArrayNonUniformIndexing( shaderInputAttachmentArrayNonUniformIndexing_ ) + , shaderUniformTexelBufferArrayNonUniformIndexing( shaderUniformTexelBufferArrayNonUniformIndexing_ ) + , shaderStorageTexelBufferArrayNonUniformIndexing( shaderStorageTexelBufferArrayNonUniformIndexing_ ) + , descriptorBindingUniformBufferUpdateAfterBind( descriptorBindingUniformBufferUpdateAfterBind_ ) + , descriptorBindingSampledImageUpdateAfterBind( descriptorBindingSampledImageUpdateAfterBind_ ) + , descriptorBindingStorageImageUpdateAfterBind( descriptorBindingStorageImageUpdateAfterBind_ ) + , descriptorBindingStorageBufferUpdateAfterBind( descriptorBindingStorageBufferUpdateAfterBind_ ) + , descriptorBindingUniformTexelBufferUpdateAfterBind( descriptorBindingUniformTexelBufferUpdateAfterBind_ ) + , descriptorBindingStorageTexelBufferUpdateAfterBind( descriptorBindingStorageTexelBufferUpdateAfterBind_ ) + , descriptorBindingUpdateUnusedWhilePending( descriptorBindingUpdateUnusedWhilePending_ ) + , descriptorBindingPartiallyBound( descriptorBindingPartiallyBound_ ) + , descriptorBindingVariableDescriptorCount( descriptorBindingVariableDescriptorCount_ ) + , runtimeDescriptorArray( runtimeDescriptorArray_ ) {} + vk::PhysicalDeviceDescriptorIndexingFeaturesEXT & operator=( vk::PhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDescriptorIndexingFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceDescriptorIndexingFeaturesEXT( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDescriptorIndexingFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceDescriptorIndexingFeaturesEXT& operator=( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceDescriptorIndexingFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46724,74 +43212,97 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceDescriptorIndexingFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 shaderInputAttachmentArrayDynamicIndexing; + vk::Bool32 shaderUniformTexelBufferArrayDynamicIndexing; + vk::Bool32 shaderStorageTexelBufferArrayDynamicIndexing; + vk::Bool32 shaderUniformBufferArrayNonUniformIndexing; + vk::Bool32 shaderSampledImageArrayNonUniformIndexing; + vk::Bool32 shaderStorageBufferArrayNonUniformIndexing; + vk::Bool32 shaderStorageImageArrayNonUniformIndexing; + vk::Bool32 shaderInputAttachmentArrayNonUniformIndexing; + vk::Bool32 shaderUniformTexelBufferArrayNonUniformIndexing; + vk::Bool32 shaderStorageTexelBufferArrayNonUniformIndexing; + vk::Bool32 descriptorBindingUniformBufferUpdateAfterBind; + vk::Bool32 descriptorBindingSampledImageUpdateAfterBind; + vk::Bool32 descriptorBindingStorageImageUpdateAfterBind; + vk::Bool32 descriptorBindingStorageBufferUpdateAfterBind; + vk::Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + vk::Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + vk::Bool32 descriptorBindingUpdateUnusedWhilePending; + vk::Bool32 descriptorBindingPartiallyBound; + vk::Bool32 descriptorBindingVariableDescriptorCount; + vk::Bool32 runtimeDescriptorArray; }; static_assert( sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceDescriptorIndexingPropertiesEXT { - struct PhysicalDeviceDescriptorIndexingPropertiesEXT - { - protected: - PhysicalDeviceDescriptorIndexingPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceDescriptorIndexingPropertiesEXT( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceDescriptorIndexingPropertiesEXT& operator=( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT; - void* pNext = nullptr; - uint32_t maxUpdateAfterBindDescriptorsInAllPools; - vk::Bool32 shaderUniformBufferArrayNonUniformIndexingNative; - vk::Bool32 shaderSampledImageArrayNonUniformIndexingNative; - vk::Bool32 shaderStorageBufferArrayNonUniformIndexingNative; - vk::Bool32 shaderStorageImageArrayNonUniformIndexingNative; - vk::Bool32 shaderInputAttachmentArrayNonUniformIndexingNative; - vk::Bool32 robustBufferAccessUpdateAfterBind; - vk::Bool32 quadDivergentImplicitLod; - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; - uint32_t maxPerStageUpdateAfterBindResources; - uint32_t maxDescriptorSetUpdateAfterBindSamplers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindSampledImages; - uint32_t maxDescriptorSetUpdateAfterBindStorageImages; - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; - }; - static_assert( sizeof( PhysicalDeviceDescriptorIndexingPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceDescriptorIndexingPropertiesEXT : public layout::PhysicalDeviceDescriptorIndexingPropertiesEXT - { - PhysicalDeviceDescriptorIndexingPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDescriptorIndexingPropertiesEXT() + PhysicalDeviceDescriptorIndexingPropertiesEXT( uint32_t maxUpdateAfterBindDescriptorsInAllPools_ = 0, + vk::Bool32 shaderUniformBufferArrayNonUniformIndexingNative_ = 0, + vk::Bool32 shaderSampledImageArrayNonUniformIndexingNative_ = 0, + vk::Bool32 shaderStorageBufferArrayNonUniformIndexingNative_ = 0, + vk::Bool32 shaderStorageImageArrayNonUniformIndexingNative_ = 0, + vk::Bool32 shaderInputAttachmentArrayNonUniformIndexingNative_ = 0, + vk::Bool32 robustBufferAccessUpdateAfterBind_ = 0, + vk::Bool32 quadDivergentImplicitLod_ = 0, + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers_ = 0, + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers_ = 0, + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers_ = 0, + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages_ = 0, + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages_ = 0, + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments_ = 0, + uint32_t maxPerStageUpdateAfterBindResources_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindSamplers_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindSampledImages_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindStorageImages_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxUpdateAfterBindDescriptorsInAllPools( maxUpdateAfterBindDescriptorsInAllPools_ ) + , shaderUniformBufferArrayNonUniformIndexingNative( shaderUniformBufferArrayNonUniformIndexingNative_ ) + , shaderSampledImageArrayNonUniformIndexingNative( shaderSampledImageArrayNonUniformIndexingNative_ ) + , shaderStorageBufferArrayNonUniformIndexingNative( shaderStorageBufferArrayNonUniformIndexingNative_ ) + , shaderStorageImageArrayNonUniformIndexingNative( shaderStorageImageArrayNonUniformIndexingNative_ ) + , shaderInputAttachmentArrayNonUniformIndexingNative( shaderInputAttachmentArrayNonUniformIndexingNative_ ) + , robustBufferAccessUpdateAfterBind( robustBufferAccessUpdateAfterBind_ ) + , quadDivergentImplicitLod( quadDivergentImplicitLod_ ) + , maxPerStageDescriptorUpdateAfterBindSamplers( maxPerStageDescriptorUpdateAfterBindSamplers_ ) + , maxPerStageDescriptorUpdateAfterBindUniformBuffers( maxPerStageDescriptorUpdateAfterBindUniformBuffers_ ) + , maxPerStageDescriptorUpdateAfterBindStorageBuffers( maxPerStageDescriptorUpdateAfterBindStorageBuffers_ ) + , maxPerStageDescriptorUpdateAfterBindSampledImages( maxPerStageDescriptorUpdateAfterBindSampledImages_ ) + , maxPerStageDescriptorUpdateAfterBindStorageImages( maxPerStageDescriptorUpdateAfterBindStorageImages_ ) + , maxPerStageDescriptorUpdateAfterBindInputAttachments( maxPerStageDescriptorUpdateAfterBindInputAttachments_ ) + , maxPerStageUpdateAfterBindResources( maxPerStageUpdateAfterBindResources_ ) + , maxDescriptorSetUpdateAfterBindSamplers( maxDescriptorSetUpdateAfterBindSamplers_ ) + , maxDescriptorSetUpdateAfterBindUniformBuffers( maxDescriptorSetUpdateAfterBindUniformBuffers_ ) + , maxDescriptorSetUpdateAfterBindUniformBuffersDynamic( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ ) + , maxDescriptorSetUpdateAfterBindStorageBuffers( maxDescriptorSetUpdateAfterBindStorageBuffers_ ) + , maxDescriptorSetUpdateAfterBindStorageBuffersDynamic( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ ) + , maxDescriptorSetUpdateAfterBindSampledImages( maxDescriptorSetUpdateAfterBindSampledImages_ ) + , maxDescriptorSetUpdateAfterBindStorageImages( maxDescriptorSetUpdateAfterBindStorageImages_ ) + , maxDescriptorSetUpdateAfterBindInputAttachments( maxDescriptorSetUpdateAfterBindInputAttachments_ ) {} + vk::PhysicalDeviceDescriptorIndexingPropertiesEXT & operator=( vk::PhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDescriptorIndexingPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceDescriptorIndexingPropertiesEXT( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDescriptorIndexingPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceDescriptorIndexingPropertiesEXT& operator=( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceDescriptorIndexingPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46839,52 +43350,56 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceDescriptorIndexingPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT; + void* pNext = nullptr; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + vk::Bool32 shaderUniformBufferArrayNonUniformIndexingNative; + vk::Bool32 shaderSampledImageArrayNonUniformIndexingNative; + vk::Bool32 shaderStorageBufferArrayNonUniformIndexingNative; + vk::Bool32 shaderStorageImageArrayNonUniformIndexingNative; + vk::Bool32 shaderInputAttachmentArrayNonUniformIndexingNative; + vk::Bool32 robustBufferAccessUpdateAfterBind; + vk::Bool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; }; static_assert( sizeof( PhysicalDeviceDescriptorIndexingPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceDiscardRectanglePropertiesEXT { - struct PhysicalDeviceDiscardRectanglePropertiesEXT - { - protected: - PhysicalDeviceDiscardRectanglePropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; - void* pNext = nullptr; - uint32_t maxDiscardRectangles; - }; - static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceDiscardRectanglePropertiesEXT : public layout::PhysicalDeviceDiscardRectanglePropertiesEXT - { - PhysicalDeviceDiscardRectanglePropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDiscardRectanglePropertiesEXT() + PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxDiscardRectangles( maxDiscardRectangles_ ) {} + vk::PhysicalDeviceDiscardRectanglePropertiesEXT & operator=( vk::PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDiscardRectanglePropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDiscardRectanglePropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceDiscardRectanglePropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46910,55 +43425,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceDiscardRectanglePropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; + void* pNext = nullptr; + uint32_t maxDiscardRectangles; }; static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceDriverPropertiesKHR { - struct PhysicalDeviceDriverPropertiesKHR + PhysicalDeviceDriverPropertiesKHR( vk::DriverIdKHR driverID_ = vk::DriverIdKHR::eAmdProprietary, + std::array const& driverName_ = { { 0 } }, + std::array const& driverInfo_ = { { 0 } }, + vk::ConformanceVersionKHR conformanceVersion_ = vk::ConformanceVersionKHR() ) VULKAN_HPP_NOEXCEPT + : driverID( driverID_ ) + , driverName{} + , driverInfo{} + , conformanceVersion( conformanceVersion_ ) { - protected: - PhysicalDeviceDriverPropertiesKHR() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( driverName, driverName_ ); + vk::ConstExpressionArrayCopy::copy( driverInfo, driverInfo_ ); + } - PhysicalDeviceDriverPropertiesKHR( VkPhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceDriverPropertiesKHR& operator=( VkPhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceDriverPropertiesKHR; - void* pNext = nullptr; - vk::DriverIdKHR driverID; - char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR]; - char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR]; - vk::ConformanceVersionKHR conformanceVersion; - }; - static_assert( sizeof( PhysicalDeviceDriverPropertiesKHR ) == sizeof( VkPhysicalDeviceDriverPropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceDriverPropertiesKHR : public layout::PhysicalDeviceDriverPropertiesKHR - { - PhysicalDeviceDriverPropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDriverPropertiesKHR() - {} + vk::PhysicalDeviceDriverPropertiesKHR & operator=( vk::PhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceDriverPropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } PhysicalDeviceDriverPropertiesKHR( VkPhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceDriverPropertiesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceDriverPropertiesKHR& operator=( VkPhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceDriverPropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -46987,53 +43490,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceDriverPropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceDriverPropertiesKHR; + void* pNext = nullptr; + vk::DriverIdKHR driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR]; + vk::ConformanceVersionKHR conformanceVersion; }; static_assert( sizeof( PhysicalDeviceDriverPropertiesKHR ) == sizeof( VkPhysicalDeviceDriverPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceExclusiveScissorFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( vk::Bool32 exclusiveScissor_ = 0 ) VULKAN_HPP_NOEXCEPT - : exclusiveScissor( exclusiveScissor_ ) - {} - - PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceExclusiveScissorFeaturesNV& operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV; - void* pNext = nullptr; - vk::Bool32 exclusiveScissor; - }; - static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceExclusiveScissorFeaturesNV : public layout::PhysicalDeviceExclusiveScissorFeaturesNV + struct PhysicalDeviceExclusiveScissorFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( vk::Bool32 exclusiveScissor_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExclusiveScissorFeaturesNV( exclusiveScissor_ ) + : exclusiveScissor( exclusiveScissor_ ) {} + vk::PhysicalDeviceExclusiveScissorFeaturesNV & operator=( vk::PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExclusiveScissorFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExclusiveScissorFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceExclusiveScissorFeaturesNV& operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceExclusiveScissorFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47071,61 +43558,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceExclusiveScissorFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV; + void* pNext = nullptr; + vk::Bool32 exclusiveScissor; }; static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceExternalBufferInfo - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(), - vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(), - vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , usage( usage_ ) - , handleType( handleType_ ) - {} - - PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo; - const void* pNext = nullptr; - vk::BufferCreateFlags flags; - vk::BufferUsageFlags usage; - vk::ExternalMemoryHandleTypeFlagBits handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceExternalBufferInfo : public layout::PhysicalDeviceExternalBufferInfo + struct PhysicalDeviceExternalBufferInfo { VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( vk::BufferCreateFlags flags_ = vk::BufferCreateFlags(), vk::BufferUsageFlags usage_ = vk::BufferUsageFlags(), vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalBufferInfo( flags_, usage_, handleType_ ) + : flags( flags_ ) + , usage( usage_ ) + , handleType( handleType_ ) {} + vk::PhysicalDeviceExternalBufferInfo & operator=( vk::PhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalBufferInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalBufferInfo( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceExternalBufferInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47177,53 +43641,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceExternalBufferInfo::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo; + const void* pNext = nullptr; + vk::BufferCreateFlags flags; + vk::BufferUsageFlags usage; + vk::ExternalMemoryHandleTypeFlagBits handleType; }; static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceExternalFenceInfo - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : handleType( handleType_ ) - {} - - PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo; - const void* pNext = nullptr; - vk::ExternalFenceHandleTypeFlagBits handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceExternalFenceInfo : public layout::PhysicalDeviceExternalFenceInfo + struct PhysicalDeviceExternalFenceInfo { VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( vk::ExternalFenceHandleTypeFlagBits handleType_ = vk::ExternalFenceHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalFenceInfo( handleType_ ) + : handleType( handleType_ ) {} + vk::PhysicalDeviceExternalFenceInfo & operator=( vk::PhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalFenceInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalFenceInfo( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceExternalFenceInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47261,53 +43708,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceExternalFenceInfo::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo; + const void* pNext = nullptr; + vk::ExternalFenceHandleTypeFlagBits handleType; }; static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceExternalImageFormatInfo - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : handleType( handleType_ ) - {} - - PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo; - const void* pNext = nullptr; - vk::ExternalMemoryHandleTypeFlagBits handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceExternalImageFormatInfo : public layout::PhysicalDeviceExternalImageFormatInfo + struct PhysicalDeviceExternalImageFormatInfo { VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( vk::ExternalMemoryHandleTypeFlagBits handleType_ = vk::ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalImageFormatInfo( handleType_ ) + : handleType( handleType_ ) {} + vk::PhysicalDeviceExternalImageFormatInfo & operator=( vk::PhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalImageFormatInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalImageFormatInfo( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceExternalImageFormatInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47345,52 +43773,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceExternalImageFormatInfo::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo; + const void* pNext = nullptr; + vk::ExternalMemoryHandleTypeFlagBits handleType; }; static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceExternalMemoryHostPropertiesEXT { - struct PhysicalDeviceExternalMemoryHostPropertiesEXT - { - protected: - PhysicalDeviceExternalMemoryHostPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; - void* pNext = nullptr; - vk::DeviceSize minImportedHostPointerAlignment; - }; - static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceExternalMemoryHostPropertiesEXT : public layout::PhysicalDeviceExternalMemoryHostPropertiesEXT - { - PhysicalDeviceExternalMemoryHostPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalMemoryHostPropertiesEXT() + PhysicalDeviceExternalMemoryHostPropertiesEXT( vk::DeviceSize minImportedHostPointerAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT + : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ ) {} + vk::PhysicalDeviceExternalMemoryHostPropertiesEXT & operator=( vk::PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalMemoryHostPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalMemoryHostPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceExternalMemoryHostPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47416,53 +43826,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceExternalMemoryHostPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; + void* pNext = nullptr; + vk::DeviceSize minImportedHostPointerAlignment; }; static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceExternalSemaphoreInfo - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : handleType( handleType_ ) - {} - - PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo; - const void* pNext = nullptr; - vk::ExternalSemaphoreHandleTypeFlagBits handleType; - }; - static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceExternalSemaphoreInfo : public layout::PhysicalDeviceExternalSemaphoreInfo + struct PhysicalDeviceExternalSemaphoreInfo { VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalSemaphoreInfo( handleType_ ) + : handleType( handleType_ ) {} + vk::PhysicalDeviceExternalSemaphoreInfo & operator=( vk::PhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceExternalSemaphoreInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceExternalSemaphoreInfo( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceExternalSemaphoreInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47500,53 +43891,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceExternalSemaphoreInfo::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo; + const void* pNext = nullptr; + vk::ExternalSemaphoreHandleTypeFlagBits handleType; }; static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceFeatures2 - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( vk::PhysicalDeviceFeatures features_ = vk::PhysicalDeviceFeatures() ) VULKAN_HPP_NOEXCEPT - : features( features_ ) - {} - - PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceFeatures2; - void* pNext = nullptr; - vk::PhysicalDeviceFeatures features; - }; - static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceFeatures2 : public layout::PhysicalDeviceFeatures2 + struct PhysicalDeviceFeatures2 { VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( vk::PhysicalDeviceFeatures features_ = vk::PhysicalDeviceFeatures() ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFeatures2( features_ ) + : features( features_ ) {} + vk::PhysicalDeviceFeatures2 & operator=( vk::PhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFeatures2 ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFeatures2( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceFeatures2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47584,68 +43956,66 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceFeatures2::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceFeatures2; + void* pNext = nullptr; + vk::PhysicalDeviceFeatures features; }; static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceFloatControlsPropertiesKHR { - struct PhysicalDeviceFloatControlsPropertiesKHR - { - protected: - PhysicalDeviceFloatControlsPropertiesKHR() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceFloatControlsPropertiesKHR( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceFloatControlsPropertiesKHR& operator=( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceFloatControlsPropertiesKHR; - void* pNext = nullptr; - vk::ShaderFloatControlsIndependenceKHR denormBehaviorIndependence; - vk::ShaderFloatControlsIndependenceKHR roundingModeIndependence; - vk::Bool32 shaderSignedZeroInfNanPreserveFloat16; - vk::Bool32 shaderSignedZeroInfNanPreserveFloat32; - vk::Bool32 shaderSignedZeroInfNanPreserveFloat64; - vk::Bool32 shaderDenormPreserveFloat16; - vk::Bool32 shaderDenormPreserveFloat32; - vk::Bool32 shaderDenormPreserveFloat64; - vk::Bool32 shaderDenormFlushToZeroFloat16; - vk::Bool32 shaderDenormFlushToZeroFloat32; - vk::Bool32 shaderDenormFlushToZeroFloat64; - vk::Bool32 shaderRoundingModeRTEFloat16; - vk::Bool32 shaderRoundingModeRTEFloat32; - vk::Bool32 shaderRoundingModeRTEFloat64; - vk::Bool32 shaderRoundingModeRTZFloat16; - vk::Bool32 shaderRoundingModeRTZFloat32; - vk::Bool32 shaderRoundingModeRTZFloat64; - }; - static_assert( sizeof( PhysicalDeviceFloatControlsPropertiesKHR ) == sizeof( VkPhysicalDeviceFloatControlsPropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceFloatControlsPropertiesKHR : public layout::PhysicalDeviceFloatControlsPropertiesKHR - { - PhysicalDeviceFloatControlsPropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFloatControlsPropertiesKHR() + PhysicalDeviceFloatControlsPropertiesKHR( vk::ShaderFloatControlsIndependenceKHR denormBehaviorIndependence_ = vk::ShaderFloatControlsIndependenceKHR::e32BitOnly, + vk::ShaderFloatControlsIndependenceKHR roundingModeIndependence_ = vk::ShaderFloatControlsIndependenceKHR::e32BitOnly, + vk::Bool32 shaderSignedZeroInfNanPreserveFloat16_ = 0, + vk::Bool32 shaderSignedZeroInfNanPreserveFloat32_ = 0, + vk::Bool32 shaderSignedZeroInfNanPreserveFloat64_ = 0, + vk::Bool32 shaderDenormPreserveFloat16_ = 0, + vk::Bool32 shaderDenormPreserveFloat32_ = 0, + vk::Bool32 shaderDenormPreserveFloat64_ = 0, + vk::Bool32 shaderDenormFlushToZeroFloat16_ = 0, + vk::Bool32 shaderDenormFlushToZeroFloat32_ = 0, + vk::Bool32 shaderDenormFlushToZeroFloat64_ = 0, + vk::Bool32 shaderRoundingModeRTEFloat16_ = 0, + vk::Bool32 shaderRoundingModeRTEFloat32_ = 0, + vk::Bool32 shaderRoundingModeRTEFloat64_ = 0, + vk::Bool32 shaderRoundingModeRTZFloat16_ = 0, + vk::Bool32 shaderRoundingModeRTZFloat32_ = 0, + vk::Bool32 shaderRoundingModeRTZFloat64_ = 0 ) VULKAN_HPP_NOEXCEPT + : denormBehaviorIndependence( denormBehaviorIndependence_ ) + , roundingModeIndependence( roundingModeIndependence_ ) + , shaderSignedZeroInfNanPreserveFloat16( shaderSignedZeroInfNanPreserveFloat16_ ) + , shaderSignedZeroInfNanPreserveFloat32( shaderSignedZeroInfNanPreserveFloat32_ ) + , shaderSignedZeroInfNanPreserveFloat64( shaderSignedZeroInfNanPreserveFloat64_ ) + , shaderDenormPreserveFloat16( shaderDenormPreserveFloat16_ ) + , shaderDenormPreserveFloat32( shaderDenormPreserveFloat32_ ) + , shaderDenormPreserveFloat64( shaderDenormPreserveFloat64_ ) + , shaderDenormFlushToZeroFloat16( shaderDenormFlushToZeroFloat16_ ) + , shaderDenormFlushToZeroFloat32( shaderDenormFlushToZeroFloat32_ ) + , shaderDenormFlushToZeroFloat64( shaderDenormFlushToZeroFloat64_ ) + , shaderRoundingModeRTEFloat16( shaderRoundingModeRTEFloat16_ ) + , shaderRoundingModeRTEFloat32( shaderRoundingModeRTEFloat32_ ) + , shaderRoundingModeRTEFloat64( shaderRoundingModeRTEFloat64_ ) + , shaderRoundingModeRTZFloat16( shaderRoundingModeRTZFloat16_ ) + , shaderRoundingModeRTZFloat32( shaderRoundingModeRTZFloat32_ ) + , shaderRoundingModeRTZFloat64( shaderRoundingModeRTZFloat64_ ) {} + vk::PhysicalDeviceFloatControlsPropertiesKHR & operator=( vk::PhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFloatControlsPropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceFloatControlsPropertiesKHR( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFloatControlsPropertiesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceFloatControlsPropertiesKHR& operator=( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceFloatControlsPropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47687,54 +44057,54 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceFloatControlsPropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceFloatControlsPropertiesKHR; + void* pNext = nullptr; + vk::ShaderFloatControlsIndependenceKHR denormBehaviorIndependence; + vk::ShaderFloatControlsIndependenceKHR roundingModeIndependence; + vk::Bool32 shaderSignedZeroInfNanPreserveFloat16; + vk::Bool32 shaderSignedZeroInfNanPreserveFloat32; + vk::Bool32 shaderSignedZeroInfNanPreserveFloat64; + vk::Bool32 shaderDenormPreserveFloat16; + vk::Bool32 shaderDenormPreserveFloat32; + vk::Bool32 shaderDenormPreserveFloat64; + vk::Bool32 shaderDenormFlushToZeroFloat16; + vk::Bool32 shaderDenormFlushToZeroFloat32; + vk::Bool32 shaderDenormFlushToZeroFloat64; + vk::Bool32 shaderRoundingModeRTEFloat16; + vk::Bool32 shaderRoundingModeRTEFloat32; + vk::Bool32 shaderRoundingModeRTEFloat64; + vk::Bool32 shaderRoundingModeRTZFloat16; + vk::Bool32 shaderRoundingModeRTZFloat32; + vk::Bool32 shaderRoundingModeRTZFloat64; }; static_assert( sizeof( PhysicalDeviceFloatControlsPropertiesKHR ) == sizeof( VkPhysicalDeviceFloatControlsPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceFragmentDensityMapFeaturesEXT { - struct PhysicalDeviceFragmentDensityMapFeaturesEXT - { - protected: - PhysicalDeviceFragmentDensityMapFeaturesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceFragmentDensityMapFeaturesEXT( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceFragmentDensityMapFeaturesEXT& operator=( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 fragmentDensityMap; - vk::Bool32 fragmentDensityMapDynamic; - vk::Bool32 fragmentDensityMapNonSubsampledImages; - }; - static_assert( sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceFragmentDensityMapFeaturesEXT : public layout::PhysicalDeviceFragmentDensityMapFeaturesEXT - { - PhysicalDeviceFragmentDensityMapFeaturesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentDensityMapFeaturesEXT() + PhysicalDeviceFragmentDensityMapFeaturesEXT( vk::Bool32 fragmentDensityMap_ = 0, + vk::Bool32 fragmentDensityMapDynamic_ = 0, + vk::Bool32 fragmentDensityMapNonSubsampledImages_ = 0 ) VULKAN_HPP_NOEXCEPT + : fragmentDensityMap( fragmentDensityMap_ ) + , fragmentDensityMapDynamic( fragmentDensityMapDynamic_ ) + , fragmentDensityMapNonSubsampledImages( fragmentDensityMapNonSubsampledImages_ ) {} + vk::PhysicalDeviceFragmentDensityMapFeaturesEXT & operator=( vk::PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFragmentDensityMapFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceFragmentDensityMapFeaturesEXT( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentDensityMapFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceFragmentDensityMapFeaturesEXT& operator=( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceFragmentDensityMapFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47762,54 +44132,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceFragmentDensityMapFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 fragmentDensityMap; + vk::Bool32 fragmentDensityMapDynamic; + vk::Bool32 fragmentDensityMapNonSubsampledImages; }; static_assert( sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceFragmentDensityMapPropertiesEXT { - struct PhysicalDeviceFragmentDensityMapPropertiesEXT - { - protected: - PhysicalDeviceFragmentDensityMapPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceFragmentDensityMapPropertiesEXT( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceFragmentDensityMapPropertiesEXT& operator=( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT; - void* pNext = nullptr; - vk::Extent2D minFragmentDensityTexelSize; - vk::Extent2D maxFragmentDensityTexelSize; - vk::Bool32 fragmentDensityInvocations; - }; - static_assert( sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceFragmentDensityMapPropertiesEXT : public layout::PhysicalDeviceFragmentDensityMapPropertiesEXT - { - PhysicalDeviceFragmentDensityMapPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentDensityMapPropertiesEXT() + PhysicalDeviceFragmentDensityMapPropertiesEXT( vk::Extent2D minFragmentDensityTexelSize_ = vk::Extent2D(), + vk::Extent2D maxFragmentDensityTexelSize_ = vk::Extent2D(), + vk::Bool32 fragmentDensityInvocations_ = 0 ) VULKAN_HPP_NOEXCEPT + : minFragmentDensityTexelSize( minFragmentDensityTexelSize_ ) + , maxFragmentDensityTexelSize( maxFragmentDensityTexelSize_ ) + , fragmentDensityInvocations( fragmentDensityInvocations_ ) {} + vk::PhysicalDeviceFragmentDensityMapPropertiesEXT & operator=( vk::PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFragmentDensityMapPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceFragmentDensityMapPropertiesEXT( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentDensityMapPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceFragmentDensityMapPropertiesEXT& operator=( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceFragmentDensityMapPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47837,53 +44193,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceFragmentDensityMapPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT; + void* pNext = nullptr; + vk::Extent2D minFragmentDensityTexelSize; + vk::Extent2D maxFragmentDensityTexelSize; + vk::Bool32 fragmentDensityInvocations; }; static_assert( sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) == sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesNV( vk::Bool32 fragmentShaderBarycentric_ = 0 ) VULKAN_HPP_NOEXCEPT - : fragmentShaderBarycentric( fragmentShaderBarycentric_ ) - {} - - PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV; - void* pNext = nullptr; - vk::Bool32 fragmentShaderBarycentric; - }; - static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV : public layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV + struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesNV( vk::Bool32 fragmentShaderBarycentric_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV( fragmentShaderBarycentric_ ) + : fragmentShaderBarycentric( fragmentShaderBarycentric_ ) {} + vk::PhysicalDeviceFragmentShaderBarycentricFeaturesNV & operator=( vk::PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceFragmentShaderBarycentricFeaturesNV( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -47921,61 +44260,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceFragmentShaderBarycentricFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV; + void* pNext = nullptr; + vk::Bool32 fragmentShaderBarycentric; }; static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( vk::Bool32 fragmentShaderSampleInterlock_ = 0, - vk::Bool32 fragmentShaderPixelInterlock_ = 0, - vk::Bool32 fragmentShaderShadingRateInterlock_ = 0 ) VULKAN_HPP_NOEXCEPT - : fragmentShaderSampleInterlock( fragmentShaderSampleInterlock_ ) - , fragmentShaderPixelInterlock( fragmentShaderPixelInterlock_ ) - , fragmentShaderShadingRateInterlock( fragmentShaderShadingRateInterlock_ ) - {} - - PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 fragmentShaderSampleInterlock; - vk::Bool32 fragmentShaderPixelInterlock; - vk::Bool32 fragmentShaderShadingRateInterlock; - }; - static_assert( sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT : public layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT + struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( vk::Bool32 fragmentShaderSampleInterlock_ = 0, vk::Bool32 fragmentShaderPixelInterlock_ = 0, vk::Bool32 fragmentShaderShadingRateInterlock_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT( fragmentShaderSampleInterlock_, fragmentShaderPixelInterlock_, fragmentShaderShadingRateInterlock_ ) + : fragmentShaderSampleInterlock( fragmentShaderSampleInterlock_ ) + , fragmentShaderPixelInterlock( fragmentShaderPixelInterlock_ ) + , fragmentShaderShadingRateInterlock( fragmentShaderShadingRateInterlock_ ) {} + vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT & operator=( vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48027,54 +44343,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceFragmentShaderInterlockFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 fragmentShaderSampleInterlock; + vk::Bool32 fragmentShaderPixelInterlock; + vk::Bool32 fragmentShaderShadingRateInterlock; }; static_assert( sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) == sizeof( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceGroupProperties { - struct PhysicalDeviceGroupProperties + PhysicalDeviceGroupProperties( uint32_t physicalDeviceCount_ = 0, + std::array const& physicalDevices_ = { { vk::PhysicalDevice() } }, + vk::Bool32 subsetAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT + : physicalDeviceCount( physicalDeviceCount_ ) + , physicalDevices{} + , subsetAllocation( subsetAllocation_ ) { - protected: - PhysicalDeviceGroupProperties() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( physicalDevices, physicalDevices_ ); + } - PhysicalDeviceGroupProperties( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceGroupProperties& operator=( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceGroupProperties; - void* pNext = nullptr; - uint32_t physicalDeviceCount; - vk::PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; - vk::Bool32 subsetAllocation; - }; - static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceGroupProperties : public layout::PhysicalDeviceGroupProperties - { - PhysicalDeviceGroupProperties() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceGroupProperties() - {} + vk::PhysicalDeviceGroupProperties & operator=( vk::PhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceGroupProperties ) - sizeof( vk::StructureType ) ); + return *this; + } PhysicalDeviceGroupProperties( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceGroupProperties( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceGroupProperties& operator=( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceGroupProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48102,53 +44406,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceGroupProperties::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceGroupProperties; + void* pNext = nullptr; + uint32_t physicalDeviceCount; + vk::PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; + vk::Bool32 subsetAllocation; }; static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceHostQueryResetFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeaturesEXT( vk::Bool32 hostQueryReset_ = 0 ) VULKAN_HPP_NOEXCEPT - : hostQueryReset( hostQueryReset_ ) - {} - - PhysicalDeviceHostQueryResetFeaturesEXT( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceHostQueryResetFeaturesEXT& operator=( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 hostQueryReset; - }; - static_assert( sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) == sizeof( VkPhysicalDeviceHostQueryResetFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceHostQueryResetFeaturesEXT : public layout::PhysicalDeviceHostQueryResetFeaturesEXT + struct PhysicalDeviceHostQueryResetFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeaturesEXT( vk::Bool32 hostQueryReset_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceHostQueryResetFeaturesEXT( hostQueryReset_ ) + : hostQueryReset( hostQueryReset_ ) {} + vk::PhysicalDeviceHostQueryResetFeaturesEXT & operator=( vk::PhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceHostQueryResetFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceHostQueryResetFeaturesEXT( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceHostQueryResetFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceHostQueryResetFeaturesEXT& operator=( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceHostQueryResetFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48186,56 +44473,46 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceHostQueryResetFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 hostQueryReset; }; static_assert( sizeof( PhysicalDeviceHostQueryResetFeaturesEXT ) == sizeof( VkPhysicalDeviceHostQueryResetFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceIDProperties { - struct PhysicalDeviceIDProperties + PhysicalDeviceIDProperties( std::array const& deviceUUID_ = { { 0 } }, + std::array const& driverUUID_ = { { 0 } }, + std::array const& deviceLUID_ = { { 0 } }, + uint32_t deviceNodeMask_ = 0, + vk::Bool32 deviceLUIDValid_ = 0 ) VULKAN_HPP_NOEXCEPT + : deviceUUID{} + , driverUUID{} + , deviceLUID{} + , deviceNodeMask( deviceNodeMask_ ) + , deviceLUIDValid( deviceLUIDValid_ ) { - protected: - PhysicalDeviceIDProperties() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( deviceUUID, deviceUUID_ ); + vk::ConstExpressionArrayCopy::copy( driverUUID, driverUUID_ ); + vk::ConstExpressionArrayCopy::copy( deviceLUID, deviceLUID_ ); + } - PhysicalDeviceIDProperties( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceIDProperties& operator=( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceIdProperties; - void* pNext = nullptr; - uint8_t deviceUUID[VK_UUID_SIZE]; - uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE]; - uint32_t deviceNodeMask; - vk::Bool32 deviceLUIDValid; - }; - static_assert( sizeof( PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceIDProperties : public layout::PhysicalDeviceIDProperties - { - PhysicalDeviceIDProperties() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceIDProperties() - {} + vk::PhysicalDeviceIDProperties & operator=( vk::PhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceIDProperties ) - sizeof( vk::StructureType ) ); + return *this; + } PhysicalDeviceIDProperties( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceIDProperties( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceIDProperties& operator=( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceIDProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48265,65 +44542,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceIDProperties::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceIdProperties; + void* pNext = nullptr; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + vk::Bool32 deviceLUIDValid; }; static_assert( sizeof( PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceImageDrmFormatModifierInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0, - vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = 0, - const uint32_t* pQueueFamilyIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : drmFormatModifier( drmFormatModifier_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - {} - - PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT; - const void* pNext = nullptr; - uint64_t drmFormatModifier; - vk::SharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - }; - static_assert( sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) == sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceImageDrmFormatModifierInfoEXT : public layout::PhysicalDeviceImageDrmFormatModifierInfoEXT + struct PhysicalDeviceImageDrmFormatModifierInfoEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = 0, vk::SharingMode sharingMode_ = vk::SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImageDrmFormatModifierInfoEXT( drmFormatModifier_, sharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_ ) + : drmFormatModifier( drmFormatModifier_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( queueFamilyIndexCount_ ) + , pQueueFamilyIndices( pQueueFamilyIndices_ ) {} + vk::PhysicalDeviceImageDrmFormatModifierInfoEXT & operator=( vk::PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceImageDrmFormatModifierInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImageDrmFormatModifierInfoEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceImageDrmFormatModifierInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48382,69 +44638,45 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceImageDrmFormatModifierInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT; + const void* pNext = nullptr; + uint64_t drmFormatModifier; + vk::SharingMode sharingMode; + 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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceImageFormatInfo2 - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined, - vk::ImageType type_ = vk::ImageType::e1D, - vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal, - vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(), - vk::ImageCreateFlags flags_ = vk::ImageCreateFlags() ) VULKAN_HPP_NOEXCEPT - : format( format_ ) - , type( type_ ) - , tiling( tiling_ ) - , usage( usage_ ) - , flags( flags_ ) - {} - - PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2; - const void* pNext = nullptr; - vk::Format format; - vk::ImageType type; - vk::ImageTiling tiling; - vk::ImageUsageFlags usage; - vk::ImageCreateFlags flags; - }; - static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceImageFormatInfo2 : public layout::PhysicalDeviceImageFormatInfo2 + struct PhysicalDeviceImageFormatInfo2 { VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined, vk::ImageType type_ = vk::ImageType::e1D, vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal, vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(), vk::ImageCreateFlags flags_ = vk::ImageCreateFlags() ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImageFormatInfo2( format_, type_, tiling_, usage_, flags_ ) + : format( format_ ) + , type( type_ ) + , tiling( tiling_ ) + , usage( usage_ ) + , flags( flags_ ) {} + vk::PhysicalDeviceImageFormatInfo2 & operator=( vk::PhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceImageFormatInfo2 ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImageFormatInfo2( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceImageFormatInfo2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48510,53 +44742,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceImageFormatInfo2::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2; + const void* pNext = nullptr; + vk::Format format; + vk::ImageType type; + vk::ImageTiling tiling; + vk::ImageUsageFlags usage; + vk::ImageCreateFlags flags; }; static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceImageViewImageFormatInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( vk::ImageViewType imageViewType_ = vk::ImageViewType::e1D ) VULKAN_HPP_NOEXCEPT - : imageViewType( imageViewType_ ) - {} - - PhysicalDeviceImageViewImageFormatInfoEXT( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceImageViewImageFormatInfoEXT& operator=( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT; - void* pNext = nullptr; - vk::ImageViewType imageViewType; - }; - static_assert( sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) == sizeof( VkPhysicalDeviceImageViewImageFormatInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceImageViewImageFormatInfoEXT : public layout::PhysicalDeviceImageViewImageFormatInfoEXT + struct PhysicalDeviceImageViewImageFormatInfoEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( vk::ImageViewType imageViewType_ = vk::ImageViewType::e1D ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImageViewImageFormatInfoEXT( imageViewType_ ) + : imageViewType( imageViewType_ ) {} + vk::PhysicalDeviceImageViewImageFormatInfoEXT & operator=( vk::PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceImageViewImageFormatInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceImageViewImageFormatInfoEXT( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImageViewImageFormatInfoEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceImageViewImageFormatInfoEXT& operator=( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceImageViewImageFormatInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48594,53 +44811,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceImageViewImageFormatInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT; + void* pNext = nullptr; + vk::ImageViewType imageViewType; }; static_assert( sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) == sizeof( VkPhysicalDeviceImageViewImageFormatInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceImagelessFramebufferFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeaturesKHR( vk::Bool32 imagelessFramebuffer_ = 0 ) VULKAN_HPP_NOEXCEPT - : imagelessFramebuffer( imagelessFramebuffer_ ) - {} - - PhysicalDeviceImagelessFramebufferFeaturesKHR( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceImagelessFramebufferFeaturesKHR& operator=( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceImagelessFramebufferFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 imagelessFramebuffer; - }; - static_assert( sizeof( PhysicalDeviceImagelessFramebufferFeaturesKHR ) == sizeof( VkPhysicalDeviceImagelessFramebufferFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceImagelessFramebufferFeaturesKHR : public layout::PhysicalDeviceImagelessFramebufferFeaturesKHR + struct PhysicalDeviceImagelessFramebufferFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeaturesKHR( vk::Bool32 imagelessFramebuffer_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImagelessFramebufferFeaturesKHR( imagelessFramebuffer_ ) + : imagelessFramebuffer( imagelessFramebuffer_ ) {} + vk::PhysicalDeviceImagelessFramebufferFeaturesKHR & operator=( vk::PhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceImagelessFramebufferFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceImagelessFramebufferFeaturesKHR( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceImagelessFramebufferFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceImagelessFramebufferFeaturesKHR& operator=( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceImagelessFramebufferFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48678,53 +44876,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceImagelessFramebufferFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceImagelessFramebufferFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 imagelessFramebuffer; }; static_assert( sizeof( PhysicalDeviceImagelessFramebufferFeaturesKHR ) == sizeof( VkPhysicalDeviceImagelessFramebufferFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceIndexTypeUint8FeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( vk::Bool32 indexTypeUint8_ = 0 ) VULKAN_HPP_NOEXCEPT - : indexTypeUint8( indexTypeUint8_ ) - {} - - PhysicalDeviceIndexTypeUint8FeaturesEXT( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceIndexTypeUint8FeaturesEXT& operator=( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT; - void* pNext = nullptr; - vk::Bool32 indexTypeUint8; - }; - static_assert( sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceIndexTypeUint8FeaturesEXT : public layout::PhysicalDeviceIndexTypeUint8FeaturesEXT + struct PhysicalDeviceIndexTypeUint8FeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8FeaturesEXT( vk::Bool32 indexTypeUint8_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceIndexTypeUint8FeaturesEXT( indexTypeUint8_ ) + : indexTypeUint8( indexTypeUint8_ ) {} + vk::PhysicalDeviceIndexTypeUint8FeaturesEXT & operator=( vk::PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceIndexTypeUint8FeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceIndexTypeUint8FeaturesEXT( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceIndexTypeUint8FeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceIndexTypeUint8FeaturesEXT& operator=( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceIndexTypeUint8FeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48762,57 +44941,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceIndexTypeUint8FeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceIndexTypeUint8FeaturesEXT; + void* pNext = nullptr; + vk::Bool32 indexTypeUint8; }; static_assert( sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) == sizeof( VkPhysicalDeviceIndexTypeUint8FeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceInlineUniformBlockFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeaturesEXT( vk::Bool32 inlineUniformBlock_ = 0, - vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = 0 ) VULKAN_HPP_NOEXCEPT - : inlineUniformBlock( inlineUniformBlock_ ) - , descriptorBindingInlineUniformBlockUpdateAfterBind( descriptorBindingInlineUniformBlockUpdateAfterBind_ ) - {} - - PhysicalDeviceInlineUniformBlockFeaturesEXT( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceInlineUniformBlockFeaturesEXT& operator=( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 inlineUniformBlock; - vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind; - }; - static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceInlineUniformBlockFeaturesEXT : public layout::PhysicalDeviceInlineUniformBlockFeaturesEXT + struct PhysicalDeviceInlineUniformBlockFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeaturesEXT( vk::Bool32 inlineUniformBlock_ = 0, vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceInlineUniformBlockFeaturesEXT( inlineUniformBlock_, descriptorBindingInlineUniformBlockUpdateAfterBind_ ) + : inlineUniformBlock( inlineUniformBlock_ ) + , descriptorBindingInlineUniformBlockUpdateAfterBind( descriptorBindingInlineUniformBlockUpdateAfterBind_ ) {} + vk::PhysicalDeviceInlineUniformBlockFeaturesEXT & operator=( vk::PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceInlineUniformBlockFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceInlineUniformBlockFeaturesEXT( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceInlineUniformBlockFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceInlineUniformBlockFeaturesEXT& operator=( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceInlineUniformBlockFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48857,56 +45015,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceInlineUniformBlockFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 inlineUniformBlock; + vk::Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind; }; static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceInlineUniformBlockPropertiesEXT { - struct PhysicalDeviceInlineUniformBlockPropertiesEXT - { - protected: - PhysicalDeviceInlineUniformBlockPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceInlineUniformBlockPropertiesEXT( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceInlineUniformBlockPropertiesEXT& operator=( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT; - void* pNext = nullptr; - uint32_t maxInlineUniformBlockSize; - uint32_t maxPerStageDescriptorInlineUniformBlocks; - uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; - uint32_t maxDescriptorSetInlineUniformBlocks; - uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; - }; - static_assert( sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceInlineUniformBlockPropertiesEXT : public layout::PhysicalDeviceInlineUniformBlockPropertiesEXT - { - PhysicalDeviceInlineUniformBlockPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceInlineUniformBlockPropertiesEXT() + PhysicalDeviceInlineUniformBlockPropertiesEXT( uint32_t maxInlineUniformBlockSize_ = 0, + uint32_t maxPerStageDescriptorInlineUniformBlocks_ = 0, + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ = 0, + uint32_t maxDescriptorSetInlineUniformBlocks_ = 0, + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxInlineUniformBlockSize( maxInlineUniformBlockSize_ ) + , maxPerStageDescriptorInlineUniformBlocks( maxPerStageDescriptorInlineUniformBlocks_ ) + , maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ ) + , maxDescriptorSetInlineUniformBlocks( maxDescriptorSetInlineUniformBlocks_ ) + , maxDescriptorSetUpdateAfterBindInlineUniformBlocks( maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ ) {} + vk::PhysicalDeviceInlineUniformBlockPropertiesEXT & operator=( vk::PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceInlineUniformBlockPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceInlineUniformBlockPropertiesEXT( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceInlineUniformBlockPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceInlineUniformBlockPropertiesEXT& operator=( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceInlineUniformBlockPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -48936,25 +45081,249 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceInlineUniformBlockPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT; + void* pNext = nullptr; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + 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::value, "struct wrapper is not a standard layout!" ); struct PhysicalDeviceLimits { - PhysicalDeviceLimits() VULKAN_HPP_NOEXCEPT - {} + PhysicalDeviceLimits( uint32_t maxImageDimension1D_ = 0, + uint32_t maxImageDimension2D_ = 0, + uint32_t maxImageDimension3D_ = 0, + uint32_t maxImageDimensionCube_ = 0, + uint32_t maxImageArrayLayers_ = 0, + uint32_t maxTexelBufferElements_ = 0, + uint32_t maxUniformBufferRange_ = 0, + uint32_t maxStorageBufferRange_ = 0, + uint32_t maxPushConstantsSize_ = 0, + uint32_t maxMemoryAllocationCount_ = 0, + uint32_t maxSamplerAllocationCount_ = 0, + vk::DeviceSize bufferImageGranularity_ = 0, + vk::DeviceSize sparseAddressSpaceSize_ = 0, + uint32_t maxBoundDescriptorSets_ = 0, + uint32_t maxPerStageDescriptorSamplers_ = 0, + uint32_t maxPerStageDescriptorUniformBuffers_ = 0, + uint32_t maxPerStageDescriptorStorageBuffers_ = 0, + uint32_t maxPerStageDescriptorSampledImages_ = 0, + uint32_t maxPerStageDescriptorStorageImages_ = 0, + uint32_t maxPerStageDescriptorInputAttachments_ = 0, + uint32_t maxPerStageResources_ = 0, + uint32_t maxDescriptorSetSamplers_ = 0, + uint32_t maxDescriptorSetUniformBuffers_ = 0, + uint32_t maxDescriptorSetUniformBuffersDynamic_ = 0, + uint32_t maxDescriptorSetStorageBuffers_ = 0, + uint32_t maxDescriptorSetStorageBuffersDynamic_ = 0, + uint32_t maxDescriptorSetSampledImages_ = 0, + uint32_t maxDescriptorSetStorageImages_ = 0, + uint32_t maxDescriptorSetInputAttachments_ = 0, + uint32_t maxVertexInputAttributes_ = 0, + uint32_t maxVertexInputBindings_ = 0, + uint32_t maxVertexInputAttributeOffset_ = 0, + uint32_t maxVertexInputBindingStride_ = 0, + uint32_t maxVertexOutputComponents_ = 0, + uint32_t maxTessellationGenerationLevel_ = 0, + uint32_t maxTessellationPatchSize_ = 0, + uint32_t maxTessellationControlPerVertexInputComponents_ = 0, + uint32_t maxTessellationControlPerVertexOutputComponents_ = 0, + uint32_t maxTessellationControlPerPatchOutputComponents_ = 0, + uint32_t maxTessellationControlTotalOutputComponents_ = 0, + uint32_t maxTessellationEvaluationInputComponents_ = 0, + uint32_t maxTessellationEvaluationOutputComponents_ = 0, + uint32_t maxGeometryShaderInvocations_ = 0, + uint32_t maxGeometryInputComponents_ = 0, + uint32_t maxGeometryOutputComponents_ = 0, + uint32_t maxGeometryOutputVertices_ = 0, + uint32_t maxGeometryTotalOutputComponents_ = 0, + uint32_t maxFragmentInputComponents_ = 0, + uint32_t maxFragmentOutputAttachments_ = 0, + uint32_t maxFragmentDualSrcAttachments_ = 0, + uint32_t maxFragmentCombinedOutputResources_ = 0, + uint32_t maxComputeSharedMemorySize_ = 0, + std::array const& maxComputeWorkGroupCount_ = { { 0 } }, + uint32_t maxComputeWorkGroupInvocations_ = 0, + std::array const& maxComputeWorkGroupSize_ = { { 0 } }, + uint32_t subPixelPrecisionBits_ = 0, + uint32_t subTexelPrecisionBits_ = 0, + uint32_t mipmapPrecisionBits_ = 0, + uint32_t maxDrawIndexedIndexValue_ = 0, + uint32_t maxDrawIndirectCount_ = 0, + float maxSamplerLodBias_ = 0, + float maxSamplerAnisotropy_ = 0, + uint32_t maxViewports_ = 0, + std::array const& maxViewportDimensions_ = { { 0 } }, + std::array const& viewportBoundsRange_ = { { 0 } }, + uint32_t viewportSubPixelBits_ = 0, + size_t minMemoryMapAlignment_ = 0, + vk::DeviceSize minTexelBufferOffsetAlignment_ = 0, + vk::DeviceSize minUniformBufferOffsetAlignment_ = 0, + vk::DeviceSize minStorageBufferOffsetAlignment_ = 0, + int32_t minTexelOffset_ = 0, + uint32_t maxTexelOffset_ = 0, + int32_t minTexelGatherOffset_ = 0, + uint32_t maxTexelGatherOffset_ = 0, + float minInterpolationOffset_ = 0, + float maxInterpolationOffset_ = 0, + uint32_t subPixelInterpolationOffsetBits_ = 0, + uint32_t maxFramebufferWidth_ = 0, + uint32_t maxFramebufferHeight_ = 0, + uint32_t maxFramebufferLayers_ = 0, + vk::SampleCountFlags framebufferColorSampleCounts_ = vk::SampleCountFlags(), + vk::SampleCountFlags framebufferDepthSampleCounts_ = vk::SampleCountFlags(), + vk::SampleCountFlags framebufferStencilSampleCounts_ = vk::SampleCountFlags(), + vk::SampleCountFlags framebufferNoAttachmentsSampleCounts_ = vk::SampleCountFlags(), + uint32_t maxColorAttachments_ = 0, + vk::SampleCountFlags sampledImageColorSampleCounts_ = vk::SampleCountFlags(), + vk::SampleCountFlags sampledImageIntegerSampleCounts_ = vk::SampleCountFlags(), + vk::SampleCountFlags sampledImageDepthSampleCounts_ = vk::SampleCountFlags(), + vk::SampleCountFlags sampledImageStencilSampleCounts_ = vk::SampleCountFlags(), + vk::SampleCountFlags storageImageSampleCounts_ = vk::SampleCountFlags(), + uint32_t maxSampleMaskWords_ = 0, + vk::Bool32 timestampComputeAndGraphics_ = 0, + float timestampPeriod_ = 0, + uint32_t maxClipDistances_ = 0, + uint32_t maxCullDistances_ = 0, + uint32_t maxCombinedClipAndCullDistances_ = 0, + uint32_t discreteQueuePriorities_ = 0, + std::array const& pointSizeRange_ = { { 0 } }, + std::array const& lineWidthRange_ = { { 0 } }, + float pointSizeGranularity_ = 0, + float lineWidthGranularity_ = 0, + vk::Bool32 strictLines_ = 0, + vk::Bool32 standardSampleLocations_ = 0, + vk::DeviceSize optimalBufferCopyOffsetAlignment_ = 0, + vk::DeviceSize optimalBufferCopyRowPitchAlignment_ = 0, + vk::DeviceSize nonCoherentAtomSize_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxImageDimension1D( maxImageDimension1D_ ) + , maxImageDimension2D( maxImageDimension2D_ ) + , maxImageDimension3D( maxImageDimension3D_ ) + , maxImageDimensionCube( maxImageDimensionCube_ ) + , maxImageArrayLayers( maxImageArrayLayers_ ) + , maxTexelBufferElements( maxTexelBufferElements_ ) + , maxUniformBufferRange( maxUniformBufferRange_ ) + , maxStorageBufferRange( maxStorageBufferRange_ ) + , maxPushConstantsSize( maxPushConstantsSize_ ) + , maxMemoryAllocationCount( maxMemoryAllocationCount_ ) + , maxSamplerAllocationCount( maxSamplerAllocationCount_ ) + , bufferImageGranularity( bufferImageGranularity_ ) + , sparseAddressSpaceSize( sparseAddressSpaceSize_ ) + , maxBoundDescriptorSets( maxBoundDescriptorSets_ ) + , maxPerStageDescriptorSamplers( maxPerStageDescriptorSamplers_ ) + , maxPerStageDescriptorUniformBuffers( maxPerStageDescriptorUniformBuffers_ ) + , maxPerStageDescriptorStorageBuffers( maxPerStageDescriptorStorageBuffers_ ) + , maxPerStageDescriptorSampledImages( maxPerStageDescriptorSampledImages_ ) + , maxPerStageDescriptorStorageImages( maxPerStageDescriptorStorageImages_ ) + , maxPerStageDescriptorInputAttachments( maxPerStageDescriptorInputAttachments_ ) + , maxPerStageResources( maxPerStageResources_ ) + , maxDescriptorSetSamplers( maxDescriptorSetSamplers_ ) + , maxDescriptorSetUniformBuffers( maxDescriptorSetUniformBuffers_ ) + , maxDescriptorSetUniformBuffersDynamic( maxDescriptorSetUniformBuffersDynamic_ ) + , maxDescriptorSetStorageBuffers( maxDescriptorSetStorageBuffers_ ) + , maxDescriptorSetStorageBuffersDynamic( maxDescriptorSetStorageBuffersDynamic_ ) + , maxDescriptorSetSampledImages( maxDescriptorSetSampledImages_ ) + , maxDescriptorSetStorageImages( maxDescriptorSetStorageImages_ ) + , maxDescriptorSetInputAttachments( maxDescriptorSetInputAttachments_ ) + , maxVertexInputAttributes( maxVertexInputAttributes_ ) + , maxVertexInputBindings( maxVertexInputBindings_ ) + , maxVertexInputAttributeOffset( maxVertexInputAttributeOffset_ ) + , maxVertexInputBindingStride( maxVertexInputBindingStride_ ) + , maxVertexOutputComponents( maxVertexOutputComponents_ ) + , maxTessellationGenerationLevel( maxTessellationGenerationLevel_ ) + , maxTessellationPatchSize( maxTessellationPatchSize_ ) + , maxTessellationControlPerVertexInputComponents( maxTessellationControlPerVertexInputComponents_ ) + , maxTessellationControlPerVertexOutputComponents( maxTessellationControlPerVertexOutputComponents_ ) + , maxTessellationControlPerPatchOutputComponents( maxTessellationControlPerPatchOutputComponents_ ) + , maxTessellationControlTotalOutputComponents( maxTessellationControlTotalOutputComponents_ ) + , maxTessellationEvaluationInputComponents( maxTessellationEvaluationInputComponents_ ) + , maxTessellationEvaluationOutputComponents( maxTessellationEvaluationOutputComponents_ ) + , maxGeometryShaderInvocations( maxGeometryShaderInvocations_ ) + , maxGeometryInputComponents( maxGeometryInputComponents_ ) + , maxGeometryOutputComponents( maxGeometryOutputComponents_ ) + , maxGeometryOutputVertices( maxGeometryOutputVertices_ ) + , maxGeometryTotalOutputComponents( maxGeometryTotalOutputComponents_ ) + , maxFragmentInputComponents( maxFragmentInputComponents_ ) + , maxFragmentOutputAttachments( maxFragmentOutputAttachments_ ) + , maxFragmentDualSrcAttachments( maxFragmentDualSrcAttachments_ ) + , maxFragmentCombinedOutputResources( maxFragmentCombinedOutputResources_ ) + , maxComputeSharedMemorySize( maxComputeSharedMemorySize_ ) + , maxComputeWorkGroupCount{} + , maxComputeWorkGroupInvocations( maxComputeWorkGroupInvocations_ ) + , maxComputeWorkGroupSize{} + , subPixelPrecisionBits( subPixelPrecisionBits_ ) + , subTexelPrecisionBits( subTexelPrecisionBits_ ) + , mipmapPrecisionBits( mipmapPrecisionBits_ ) + , maxDrawIndexedIndexValue( maxDrawIndexedIndexValue_ ) + , maxDrawIndirectCount( maxDrawIndirectCount_ ) + , maxSamplerLodBias( maxSamplerLodBias_ ) + , maxSamplerAnisotropy( maxSamplerAnisotropy_ ) + , maxViewports( maxViewports_ ) + , maxViewportDimensions{} + , viewportBoundsRange{} + , viewportSubPixelBits( viewportSubPixelBits_ ) + , minMemoryMapAlignment( minMemoryMapAlignment_ ) + , minTexelBufferOffsetAlignment( minTexelBufferOffsetAlignment_ ) + , minUniformBufferOffsetAlignment( minUniformBufferOffsetAlignment_ ) + , minStorageBufferOffsetAlignment( minStorageBufferOffsetAlignment_ ) + , minTexelOffset( minTexelOffset_ ) + , maxTexelOffset( maxTexelOffset_ ) + , minTexelGatherOffset( minTexelGatherOffset_ ) + , maxTexelGatherOffset( maxTexelGatherOffset_ ) + , minInterpolationOffset( minInterpolationOffset_ ) + , maxInterpolationOffset( maxInterpolationOffset_ ) + , subPixelInterpolationOffsetBits( subPixelInterpolationOffsetBits_ ) + , maxFramebufferWidth( maxFramebufferWidth_ ) + , maxFramebufferHeight( maxFramebufferHeight_ ) + , maxFramebufferLayers( maxFramebufferLayers_ ) + , framebufferColorSampleCounts( framebufferColorSampleCounts_ ) + , framebufferDepthSampleCounts( framebufferDepthSampleCounts_ ) + , framebufferStencilSampleCounts( framebufferStencilSampleCounts_ ) + , framebufferNoAttachmentsSampleCounts( framebufferNoAttachmentsSampleCounts_ ) + , maxColorAttachments( maxColorAttachments_ ) + , sampledImageColorSampleCounts( sampledImageColorSampleCounts_ ) + , sampledImageIntegerSampleCounts( sampledImageIntegerSampleCounts_ ) + , sampledImageDepthSampleCounts( sampledImageDepthSampleCounts_ ) + , sampledImageStencilSampleCounts( sampledImageStencilSampleCounts_ ) + , storageImageSampleCounts( storageImageSampleCounts_ ) + , maxSampleMaskWords( maxSampleMaskWords_ ) + , timestampComputeAndGraphics( timestampComputeAndGraphics_ ) + , timestampPeriod( timestampPeriod_ ) + , maxClipDistances( maxClipDistances_ ) + , maxCullDistances( maxCullDistances_ ) + , maxCombinedClipAndCullDistances( maxCombinedClipAndCullDistances_ ) + , discreteQueuePriorities( discreteQueuePriorities_ ) + , pointSizeRange{} + , lineWidthRange{} + , pointSizeGranularity( pointSizeGranularity_ ) + , lineWidthGranularity( lineWidthGranularity_ ) + , strictLines( strictLines_ ) + , standardSampleLocations( standardSampleLocations_ ) + , optimalBufferCopyOffsetAlignment( optimalBufferCopyOffsetAlignment_ ) + , optimalBufferCopyRowPitchAlignment( optimalBufferCopyRowPitchAlignment_ ) + , nonCoherentAtomSize( nonCoherentAtomSize_ ) + { + vk::ConstExpressionArrayCopy::copy( maxComputeWorkGroupCount, maxComputeWorkGroupCount_ ); + vk::ConstExpressionArrayCopy::copy( maxComputeWorkGroupSize, maxComputeWorkGroupSize_ ); + vk::ConstExpressionArrayCopy::copy( maxViewportDimensions, maxViewportDimensions_ ); + vk::ConstExpressionArrayCopy::copy( viewportBoundsRange, viewportBoundsRange_ ); + vk::ConstExpressionArrayCopy::copy( pointSizeRange, pointSizeRange_ ); + vk::ConstExpressionArrayCopy::copy( lineWidthRange, lineWidthRange_ ); + } PhysicalDeviceLimits( VkPhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PhysicalDeviceLimits& operator=( VkPhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -49194,50 +45563,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceLineRasterizationFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesEXT( vk::Bool32 rectangularLines_ = 0, - vk::Bool32 bresenhamLines_ = 0, - vk::Bool32 smoothLines_ = 0, - vk::Bool32 stippledRectangularLines_ = 0, - vk::Bool32 stippledBresenhamLines_ = 0, - vk::Bool32 stippledSmoothLines_ = 0 ) VULKAN_HPP_NOEXCEPT - : rectangularLines( rectangularLines_ ) - , bresenhamLines( bresenhamLines_ ) - , smoothLines( smoothLines_ ) - , stippledRectangularLines( stippledRectangularLines_ ) - , stippledBresenhamLines( stippledBresenhamLines_ ) - , stippledSmoothLines( stippledSmoothLines_ ) - {} - - PhysicalDeviceLineRasterizationFeaturesEXT( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceLineRasterizationFeaturesEXT& operator=( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 rectangularLines; - vk::Bool32 bresenhamLines; - vk::Bool32 smoothLines; - vk::Bool32 stippledRectangularLines; - vk::Bool32 stippledBresenhamLines; - vk::Bool32 stippledSmoothLines; - }; - static_assert( sizeof( PhysicalDeviceLineRasterizationFeaturesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceLineRasterizationFeaturesEXT : public layout::PhysicalDeviceLineRasterizationFeaturesEXT + struct PhysicalDeviceLineRasterizationFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeaturesEXT( vk::Bool32 rectangularLines_ = 0, vk::Bool32 bresenhamLines_ = 0, @@ -49245,16 +45571,28 @@ namespace VULKAN_HPP_NAMESPACE vk::Bool32 stippledRectangularLines_ = 0, vk::Bool32 stippledBresenhamLines_ = 0, vk::Bool32 stippledSmoothLines_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceLineRasterizationFeaturesEXT( rectangularLines_, bresenhamLines_, smoothLines_, stippledRectangularLines_, stippledBresenhamLines_, stippledSmoothLines_ ) + : rectangularLines( rectangularLines_ ) + , bresenhamLines( bresenhamLines_ ) + , smoothLines( smoothLines_ ) + , stippledRectangularLines( stippledRectangularLines_ ) + , stippledBresenhamLines( stippledBresenhamLines_ ) + , stippledSmoothLines( stippledSmoothLines_ ) {} + vk::PhysicalDeviceLineRasterizationFeaturesEXT & operator=( vk::PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceLineRasterizationFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceLineRasterizationFeaturesEXT( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceLineRasterizationFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceLineRasterizationFeaturesEXT& operator=( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceLineRasterizationFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49327,52 +45665,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceLineRasterizationFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 rectangularLines; + vk::Bool32 bresenhamLines; + vk::Bool32 smoothLines; + vk::Bool32 stippledRectangularLines; + vk::Bool32 stippledBresenhamLines; + vk::Bool32 stippledSmoothLines; }; static_assert( sizeof( PhysicalDeviceLineRasterizationFeaturesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceLineRasterizationPropertiesEXT { - struct PhysicalDeviceLineRasterizationPropertiesEXT - { - protected: - PhysicalDeviceLineRasterizationPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceLineRasterizationPropertiesEXT( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceLineRasterizationPropertiesEXT& operator=( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT; - void* pNext = nullptr; - uint32_t lineSubPixelPrecisionBits; - }; - static_assert( sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceLineRasterizationPropertiesEXT : public layout::PhysicalDeviceLineRasterizationPropertiesEXT - { - PhysicalDeviceLineRasterizationPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceLineRasterizationPropertiesEXT() + PhysicalDeviceLineRasterizationPropertiesEXT( uint32_t lineSubPixelPrecisionBits_ = 0 ) VULKAN_HPP_NOEXCEPT + : lineSubPixelPrecisionBits( lineSubPixelPrecisionBits_ ) {} + vk::PhysicalDeviceLineRasterizationPropertiesEXT & operator=( vk::PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceLineRasterizationPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceLineRasterizationPropertiesEXT( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceLineRasterizationPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceLineRasterizationPropertiesEXT& operator=( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceLineRasterizationPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49398,53 +45723,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceLineRasterizationPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceLineRasterizationPropertiesEXT; + void* pNext = nullptr; + uint32_t lineSubPixelPrecisionBits; }; static_assert( sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceLineRasterizationPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceMaintenance3Properties { - struct PhysicalDeviceMaintenance3Properties - { - protected: - PhysicalDeviceMaintenance3Properties() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceMaintenance3Properties( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMaintenance3Properties& operator=( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties; - void* pNext = nullptr; - uint32_t maxPerSetDescriptors; - vk::DeviceSize maxMemoryAllocationSize; - }; - static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMaintenance3Properties : public layout::PhysicalDeviceMaintenance3Properties - { - PhysicalDeviceMaintenance3Properties() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMaintenance3Properties() + PhysicalDeviceMaintenance3Properties( uint32_t maxPerSetDescriptors_ = 0, + vk::DeviceSize maxMemoryAllocationSize_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxPerSetDescriptors( maxPerSetDescriptors_ ) + , maxMemoryAllocationSize( maxMemoryAllocationSize_ ) {} + vk::PhysicalDeviceMaintenance3Properties & operator=( vk::PhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMaintenance3Properties ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceMaintenance3Properties( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMaintenance3Properties( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMaintenance3Properties& operator=( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMaintenance3Properties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49471,53 +45779,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMaintenance3Properties::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties; + void* pNext = nullptr; + uint32_t maxPerSetDescriptors; + vk::DeviceSize maxMemoryAllocationSize; }; static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceMemoryBudgetPropertiesEXT { - struct PhysicalDeviceMemoryBudgetPropertiesEXT + PhysicalDeviceMemoryBudgetPropertiesEXT( std::array const& heapBudget_ = { { 0 } }, + std::array const& heapUsage_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT + : heapBudget{} + , heapUsage{} { - protected: - PhysicalDeviceMemoryBudgetPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( heapBudget, heapBudget_ ); + vk::ConstExpressionArrayCopy::copy( heapUsage, heapUsage_ ); + } - PhysicalDeviceMemoryBudgetPropertiesEXT( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMemoryBudgetPropertiesEXT& operator=( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT; - void* pNext = nullptr; - vk::DeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; - vk::DeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; - }; - static_assert( sizeof( PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMemoryBudgetPropertiesEXT : public layout::PhysicalDeviceMemoryBudgetPropertiesEXT - { - PhysicalDeviceMemoryBudgetPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMemoryBudgetPropertiesEXT() - {} + vk::PhysicalDeviceMemoryBudgetPropertiesEXT & operator=( vk::PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMemoryBudgetPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } PhysicalDeviceMemoryBudgetPropertiesEXT( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMemoryBudgetPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMemoryBudgetPropertiesEXT& operator=( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMemoryBudgetPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49544,53 +45839,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMemoryBudgetPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT; + void* pNext = nullptr; + vk::DeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; + vk::DeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; }; static_assert( sizeof( PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceMemoryPriorityFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( vk::Bool32 memoryPriority_ = 0 ) VULKAN_HPP_NOEXCEPT - : memoryPriority( memoryPriority_ ) - {} - - PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMemoryPriorityFeaturesEXT& operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 memoryPriority; - }; - static_assert( sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) == sizeof( VkPhysicalDeviceMemoryPriorityFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMemoryPriorityFeaturesEXT : public layout::PhysicalDeviceMemoryPriorityFeaturesEXT + struct PhysicalDeviceMemoryPriorityFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( vk::Bool32 memoryPriority_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMemoryPriorityFeaturesEXT( memoryPriority_ ) + : memoryPriority( memoryPriority_ ) {} + vk::PhysicalDeviceMemoryPriorityFeaturesEXT & operator=( vk::PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMemoryPriorityFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMemoryPriorityFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMemoryPriorityFeaturesEXT& operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMemoryPriorityFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49628,25 +45905,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMemoryPriorityFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 memoryPriority; }; static_assert( sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) == sizeof( VkPhysicalDeviceMemoryPriorityFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct PhysicalDeviceMemoryProperties { - PhysicalDeviceMemoryProperties() VULKAN_HPP_NOEXCEPT - {} + PhysicalDeviceMemoryProperties( uint32_t memoryTypeCount_ = 0, + std::array const& memoryTypes_ = { { vk::MemoryType() } }, + uint32_t memoryHeapCount_ = 0, + std::array const& memoryHeaps_ = { { vk::MemoryHeap() } } ) VULKAN_HPP_NOEXCEPT + : memoryTypeCount( memoryTypeCount_ ) + , memoryTypes{} + , memoryHeapCount( memoryHeapCount_ ) + , memoryHeaps{} + { + vk::ConstExpressionArrayCopy::copy( memoryTypes, memoryTypes_ ); + vk::ConstExpressionArrayCopy::copy( memoryHeaps, memoryHeaps_ ); + } PhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PhysicalDeviceMemoryProperties& operator=( VkPhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -49682,46 +45971,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceMemoryProperties2 { - struct PhysicalDeviceMemoryProperties2 - { - protected: - PhysicalDeviceMemoryProperties2() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceMemoryProperties2( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMemoryProperties2& operator=( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2; - void* pNext = nullptr; - vk::PhysicalDeviceMemoryProperties memoryProperties; - }; - static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMemoryProperties2 : public layout::PhysicalDeviceMemoryProperties2 - { - PhysicalDeviceMemoryProperties2() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMemoryProperties2() + PhysicalDeviceMemoryProperties2( vk::PhysicalDeviceMemoryProperties memoryProperties_ = vk::PhysicalDeviceMemoryProperties() ) VULKAN_HPP_NOEXCEPT + : memoryProperties( memoryProperties_ ) {} + vk::PhysicalDeviceMemoryProperties2 & operator=( vk::PhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMemoryProperties2 ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceMemoryProperties2( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMemoryProperties2( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMemoryProperties2& operator=( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMemoryProperties2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49747,57 +46016,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMemoryProperties2::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2; + void* pNext = nullptr; + vk::PhysicalDeviceMemoryProperties memoryProperties; }; static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceMeshShaderFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( vk::Bool32 taskShader_ = 0, - vk::Bool32 meshShader_ = 0 ) VULKAN_HPP_NOEXCEPT - : taskShader( taskShader_ ) - , meshShader( meshShader_ ) - {} - - PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV; - void* pNext = nullptr; - vk::Bool32 taskShader; - vk::Bool32 meshShader; - }; - static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMeshShaderFeaturesNV : public layout::PhysicalDeviceMeshShaderFeaturesNV + struct PhysicalDeviceMeshShaderFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( vk::Bool32 taskShader_ = 0, vk::Bool32 meshShader_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMeshShaderFeaturesNV( taskShader_, meshShader_ ) + : taskShader( taskShader_ ) + , meshShader( meshShader_ ) {} + vk::PhysicalDeviceMeshShaderFeaturesNV & operator=( vk::PhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMeshShaderFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMeshShaderFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMeshShaderFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49842,64 +46090,62 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMeshShaderFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV; + void* pNext = nullptr; + vk::Bool32 taskShader; + vk::Bool32 meshShader; }; static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceMeshShaderPropertiesNV { - struct PhysicalDeviceMeshShaderPropertiesNV + PhysicalDeviceMeshShaderPropertiesNV( uint32_t maxDrawMeshTasksCount_ = 0, + uint32_t maxTaskWorkGroupInvocations_ = 0, + std::array const& maxTaskWorkGroupSize_ = { { 0 } }, + uint32_t maxTaskTotalMemorySize_ = 0, + uint32_t maxTaskOutputCount_ = 0, + uint32_t maxMeshWorkGroupInvocations_ = 0, + std::array const& maxMeshWorkGroupSize_ = { { 0 } }, + uint32_t maxMeshTotalMemorySize_ = 0, + uint32_t maxMeshOutputVertices_ = 0, + uint32_t maxMeshOutputPrimitives_ = 0, + uint32_t maxMeshMultiviewViewCount_ = 0, + uint32_t meshOutputPerVertexGranularity_ = 0, + uint32_t meshOutputPerPrimitiveGranularity_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxDrawMeshTasksCount( maxDrawMeshTasksCount_ ) + , maxTaskWorkGroupInvocations( maxTaskWorkGroupInvocations_ ) + , maxTaskWorkGroupSize{} + , maxTaskTotalMemorySize( maxTaskTotalMemorySize_ ) + , maxTaskOutputCount( maxTaskOutputCount_ ) + , maxMeshWorkGroupInvocations( maxMeshWorkGroupInvocations_ ) + , maxMeshWorkGroupSize{} + , maxMeshTotalMemorySize( maxMeshTotalMemorySize_ ) + , maxMeshOutputVertices( maxMeshOutputVertices_ ) + , maxMeshOutputPrimitives( maxMeshOutputPrimitives_ ) + , maxMeshMultiviewViewCount( maxMeshMultiviewViewCount_ ) + , meshOutputPerVertexGranularity( meshOutputPerVertexGranularity_ ) + , meshOutputPerPrimitiveGranularity( meshOutputPerPrimitiveGranularity_ ) { - protected: - PhysicalDeviceMeshShaderPropertiesNV() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( maxTaskWorkGroupSize, maxTaskWorkGroupSize_ ); + vk::ConstExpressionArrayCopy::copy( maxMeshWorkGroupSize, maxMeshWorkGroupSize_ ); + } - PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMeshShaderPropertiesNV& operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV; - void* pNext = nullptr; - uint32_t maxDrawMeshTasksCount; - uint32_t maxTaskWorkGroupInvocations; - uint32_t maxTaskWorkGroupSize[3]; - uint32_t maxTaskTotalMemorySize; - uint32_t maxTaskOutputCount; - uint32_t maxMeshWorkGroupInvocations; - uint32_t maxMeshWorkGroupSize[3]; - uint32_t maxMeshTotalMemorySize; - uint32_t maxMeshOutputVertices; - uint32_t maxMeshOutputPrimitives; - uint32_t maxMeshMultiviewViewCount; - uint32_t meshOutputPerVertexGranularity; - uint32_t meshOutputPerPrimitiveGranularity; - }; - static_assert( sizeof( PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMeshShaderPropertiesNV : public layout::PhysicalDeviceMeshShaderPropertiesNV - { - PhysicalDeviceMeshShaderPropertiesNV() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMeshShaderPropertiesNV() - {} + vk::PhysicalDeviceMeshShaderPropertiesNV & operator=( vk::PhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMeshShaderPropertiesNV ) - sizeof( vk::StructureType ) ); + return *this; + } PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMeshShaderPropertiesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMeshShaderPropertiesNV& operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMeshShaderPropertiesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -49937,61 +46183,50 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMeshShaderPropertiesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV; + void* pNext = nullptr; + uint32_t maxDrawMeshTasksCount; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskTotalMemorySize; + uint32_t maxTaskOutputCount; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshTotalMemorySize; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + 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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceMultiviewFeatures - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( vk::Bool32 multiview_ = 0, - vk::Bool32 multiviewGeometryShader_ = 0, - vk::Bool32 multiviewTessellationShader_ = 0 ) VULKAN_HPP_NOEXCEPT - : multiview( multiview_ ) - , multiviewGeometryShader( multiviewGeometryShader_ ) - , multiviewTessellationShader( multiviewTessellationShader_ ) - {} - - PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures; - void* pNext = nullptr; - vk::Bool32 multiview; - vk::Bool32 multiviewGeometryShader; - vk::Bool32 multiviewTessellationShader; - }; - static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMultiviewFeatures : public layout::PhysicalDeviceMultiviewFeatures + struct PhysicalDeviceMultiviewFeatures { VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( vk::Bool32 multiview_ = 0, vk::Bool32 multiviewGeometryShader_ = 0, vk::Bool32 multiviewTessellationShader_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMultiviewFeatures( multiview_, multiviewGeometryShader_, multiviewTessellationShader_ ) + : multiview( multiview_ ) + , multiviewGeometryShader( multiviewGeometryShader_ ) + , multiviewTessellationShader( multiviewTessellationShader_ ) {} + vk::PhysicalDeviceMultiviewFeatures & operator=( vk::PhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMultiviewFeatures ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMultiviewFeatures( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMultiviewFeatures::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50043,52 +46278,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMultiviewFeatures::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures; + void* pNext = nullptr; + vk::Bool32 multiview; + vk::Bool32 multiviewGeometryShader; + vk::Bool32 multiviewTessellationShader; }; static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { - struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX - { - protected: - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; - void* pNext = nullptr; - vk::Bool32 perViewPositionAllComponents; - }; - static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX : public layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX - { - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX() + PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( vk::Bool32 perViewPositionAllComponents_ = 0 ) VULKAN_HPP_NOEXCEPT + : perViewPositionAllComponents( perViewPositionAllComponents_ ) {} + vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX & operator=( vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50114,53 +46333,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + void* pNext = nullptr; + vk::Bool32 perViewPositionAllComponents; }; static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceMultiviewProperties { - struct PhysicalDeviceMultiviewProperties - { - protected: - PhysicalDeviceMultiviewProperties() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceMultiviewProperties( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceMultiviewProperties& operator=( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties; - void* pNext = nullptr; - uint32_t maxMultiviewViewCount; - uint32_t maxMultiviewInstanceIndex; - }; - static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceMultiviewProperties : public layout::PhysicalDeviceMultiviewProperties - { - PhysicalDeviceMultiviewProperties() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMultiviewProperties() + PhysicalDeviceMultiviewProperties( uint32_t maxMultiviewViewCount_ = 0, + uint32_t maxMultiviewInstanceIndex_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxMultiviewViewCount( maxMultiviewViewCount_ ) + , maxMultiviewInstanceIndex( maxMultiviewInstanceIndex_ ) {} + vk::PhysicalDeviceMultiviewProperties & operator=( vk::PhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceMultiviewProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceMultiviewProperties( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceMultiviewProperties( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceMultiviewProperties& operator=( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceMultiviewProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50187,55 +46389,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceMultiviewProperties::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties; + void* pNext = nullptr; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; }; static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDevicePCIBusInfoPropertiesEXT { - struct PhysicalDevicePCIBusInfoPropertiesEXT - { - protected: - PhysicalDevicePCIBusInfoPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDevicePCIBusInfoPropertiesEXT( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDevicePCIBusInfoPropertiesEXT& operator=( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT; - void* pNext = nullptr; - uint32_t pciDomain; - uint32_t pciBus; - uint32_t pciDevice; - uint32_t pciFunction; - }; - static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDevicePCIBusInfoPropertiesEXT : public layout::PhysicalDevicePCIBusInfoPropertiesEXT - { - PhysicalDevicePCIBusInfoPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePCIBusInfoPropertiesEXT() + PhysicalDevicePCIBusInfoPropertiesEXT( uint32_t pciDomain_ = 0, + uint32_t pciBus_ = 0, + uint32_t pciDevice_ = 0, + uint32_t pciFunction_ = 0 ) VULKAN_HPP_NOEXCEPT + : pciDomain( pciDomain_ ) + , pciBus( pciBus_ ) + , pciDevice( pciDevice_ ) + , pciFunction( pciFunction_ ) {} + vk::PhysicalDevicePCIBusInfoPropertiesEXT & operator=( vk::PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePCIBusInfoPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDevicePCIBusInfoPropertiesEXT( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePCIBusInfoPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDevicePCIBusInfoPropertiesEXT& operator=( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDevicePCIBusInfoPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50264,53 +46452,165 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDevicePCIBusInfoPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT; + void* pNext = nullptr; + uint32_t pciDomain; + 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::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDevicePerformanceQueryFeaturesKHR { - struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR + VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryFeaturesKHR( vk::Bool32 performanceCounterQueryPools_ = 0, + vk::Bool32 performanceCounterMultipleQueryPools_ = 0 ) VULKAN_HPP_NOEXCEPT + : performanceCounterQueryPools( performanceCounterQueryPools_ ) + , performanceCounterMultipleQueryPools( performanceCounterMultipleQueryPools_ ) + {} + + vk::PhysicalDevicePerformanceQueryFeaturesKHR & operator=( vk::PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( vk::Bool32 pipelineExecutableInfo_ = 0 ) VULKAN_HPP_NOEXCEPT - : pipelineExecutableInfo( pipelineExecutableInfo_ ) - {} + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePerformanceQueryFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } - PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } + PhysicalDevicePerformanceQueryFeaturesKHR( VkPhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } - PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } + PhysicalDevicePerformanceQueryFeaturesKHR& operator=( VkPhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast(&rhs); + return *this; + } - public: - vk::StructureType sType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 pipelineExecutableInfo; - }; - static_assert( sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR ), "layout struct and wrapper have different size!" ); - } + PhysicalDevicePerformanceQueryFeaturesKHR & setPNext( void* pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } - struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR : public layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR + PhysicalDevicePerformanceQueryFeaturesKHR & setPerformanceCounterQueryPools( vk::Bool32 performanceCounterQueryPools_ ) VULKAN_HPP_NOEXCEPT + { + performanceCounterQueryPools = performanceCounterQueryPools_; + return *this; + } + + PhysicalDevicePerformanceQueryFeaturesKHR & setPerformanceCounterMultipleQueryPools( vk::Bool32 performanceCounterMultipleQueryPools_ ) VULKAN_HPP_NOEXCEPT + { + performanceCounterMultipleQueryPools = performanceCounterMultipleQueryPools_; + return *this; + } + + operator VkPhysicalDevicePerformanceQueryFeaturesKHR const&() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerformanceQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDevicePerformanceQueryFeaturesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( performanceCounterQueryPools == rhs.performanceCounterQueryPools ) + && ( performanceCounterMultipleQueryPools == rhs.performanceCounterMultipleQueryPools ); + } + + bool operator!=( PhysicalDevicePerformanceQueryFeaturesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + const vk::StructureType sType = StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 performanceCounterQueryPools; + vk::Bool32 performanceCounterMultipleQueryPools; + }; + static_assert( sizeof( PhysicalDevicePerformanceQueryFeaturesKHR ) == sizeof( VkPhysicalDevicePerformanceQueryFeaturesKHR ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + struct PhysicalDevicePerformanceQueryPropertiesKHR + { + PhysicalDevicePerformanceQueryPropertiesKHR( vk::Bool32 allowCommandBufferQueryCopies_ = 0 ) VULKAN_HPP_NOEXCEPT + : allowCommandBufferQueryCopies( allowCommandBufferQueryCopies_ ) + {} + + vk::PhysicalDevicePerformanceQueryPropertiesKHR & operator=( vk::PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePerformanceQueryPropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + + PhysicalDevicePerformanceQueryPropertiesKHR( VkPhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } + + PhysicalDevicePerformanceQueryPropertiesKHR& operator=( VkPhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast(&rhs); + return *this; + } + + operator VkPhysicalDevicePerformanceQueryPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerformanceQueryPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( PhysicalDevicePerformanceQueryPropertiesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( allowCommandBufferQueryCopies == rhs.allowCommandBufferQueryCopies ); + } + + bool operator!=( PhysicalDevicePerformanceQueryPropertiesKHR const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + const vk::StructureType sType = StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR; + void* pNext = nullptr; + vk::Bool32 allowCommandBufferQueryCopies; + }; + static_assert( sizeof( PhysicalDevicePerformanceQueryPropertiesKHR ) == sizeof( VkPhysicalDevicePerformanceQueryPropertiesKHR ), "struct and wrapper have different size!" ); + static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); + + struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( vk::Bool32 pipelineExecutableInfo_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( pipelineExecutableInfo_ ) + : pipelineExecutableInfo( pipelineExecutableInfo_ ) {} + vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & operator=( vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50348,52 +46648,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 pipelineExecutableInfo; }; static_assert( sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDevicePointClippingProperties { - struct PhysicalDevicePointClippingProperties - { - protected: - PhysicalDevicePointClippingProperties() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDevicePointClippingProperties( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDevicePointClippingProperties& operator=( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDevicePointClippingProperties; - void* pNext = nullptr; - vk::PointClippingBehavior pointClippingBehavior; - }; - static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDevicePointClippingProperties : public layout::PhysicalDevicePointClippingProperties - { - PhysicalDevicePointClippingProperties() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePointClippingProperties() + PhysicalDevicePointClippingProperties( vk::PointClippingBehavior pointClippingBehavior_ = vk::PointClippingBehavior::eAllClipPlanes ) VULKAN_HPP_NOEXCEPT + : pointClippingBehavior( pointClippingBehavior_ ) {} + vk::PhysicalDevicePointClippingProperties & operator=( vk::PhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePointClippingProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDevicePointClippingProperties( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePointClippingProperties( rhs ) - {} + { + *this = rhs; + } PhysicalDevicePointClippingProperties& operator=( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDevicePointClippingProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50419,25 +46701,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDevicePointClippingProperties::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDevicePointClippingProperties; + void* pNext = nullptr; + vk::PointClippingBehavior pointClippingBehavior; }; static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct PhysicalDeviceSparseProperties { - PhysicalDeviceSparseProperties() VULKAN_HPP_NOEXCEPT + PhysicalDeviceSparseProperties( vk::Bool32 residencyStandard2DBlockShape_ = 0, + vk::Bool32 residencyStandard2DMultisampleBlockShape_ = 0, + vk::Bool32 residencyStandard3DBlockShape_ = 0, + vk::Bool32 residencyAlignedMipSize_ = 0, + vk::Bool32 residencyNonResidentStrict_ = 0 ) VULKAN_HPP_NOEXCEPT + : residencyStandard2DBlockShape( residencyStandard2DBlockShape_ ) + , residencyStandard2DMultisampleBlockShape( residencyStandard2DMultisampleBlockShape_ ) + , residencyStandard3DBlockShape( residencyStandard3DBlockShape_ ) + , residencyAlignedMipSize( residencyAlignedMipSize_ ) + , residencyNonResidentStrict( residencyNonResidentStrict_ ) {} PhysicalDeviceSparseProperties( VkPhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PhysicalDeviceSparseProperties& operator=( VkPhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -50477,17 +46770,37 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceProperties { - PhysicalDeviceProperties() VULKAN_HPP_NOEXCEPT - {} + PhysicalDeviceProperties( uint32_t apiVersion_ = 0, + uint32_t driverVersion_ = 0, + uint32_t vendorID_ = 0, + uint32_t deviceID_ = 0, + vk::PhysicalDeviceType deviceType_ = vk::PhysicalDeviceType::eOther, + std::array const& deviceName_ = { { 0 } }, + std::array const& pipelineCacheUUID_ = { { 0 } }, + vk::PhysicalDeviceLimits limits_ = vk::PhysicalDeviceLimits(), + vk::PhysicalDeviceSparseProperties sparseProperties_ = vk::PhysicalDeviceSparseProperties() ) VULKAN_HPP_NOEXCEPT + : apiVersion( apiVersion_ ) + , driverVersion( driverVersion_ ) + , vendorID( vendorID_ ) + , deviceID( deviceID_ ) + , deviceType( deviceType_ ) + , deviceName{} + , pipelineCacheUUID{} + , limits( limits_ ) + , sparseProperties( sparseProperties_ ) + { + vk::ConstExpressionArrayCopy::copy( deviceName, deviceName_ ); + vk::ConstExpressionArrayCopy::copy( pipelineCacheUUID, pipelineCacheUUID_ ); + } PhysicalDeviceProperties( VkPhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PhysicalDeviceProperties& operator=( VkPhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -50533,46 +46846,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceProperties2 { - struct PhysicalDeviceProperties2 - { - protected: - PhysicalDeviceProperties2() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceProperties2( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceProperties2& operator=( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceProperties2; - void* pNext = nullptr; - vk::PhysicalDeviceProperties properties; - }; - static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceProperties2 : public layout::PhysicalDeviceProperties2 - { - PhysicalDeviceProperties2() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceProperties2() + PhysicalDeviceProperties2( vk::PhysicalDeviceProperties properties_ = vk::PhysicalDeviceProperties() ) VULKAN_HPP_NOEXCEPT + : properties( properties_ ) {} + vk::PhysicalDeviceProperties2 & operator=( vk::PhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceProperties2 ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceProperties2( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceProperties2( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceProperties2& operator=( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceProperties2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50598,53 +46891,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceProperties2::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceProperties2; + void* pNext = nullptr; + vk::PhysicalDeviceProperties properties; }; static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceProtectedMemoryFeatures - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( vk::Bool32 protectedMemory_ = 0 ) VULKAN_HPP_NOEXCEPT - : protectedMemory( protectedMemory_ ) - {} - - PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures; - void* pNext = nullptr; - vk::Bool32 protectedMemory; - }; - static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceProtectedMemoryFeatures : public layout::PhysicalDeviceProtectedMemoryFeatures + struct PhysicalDeviceProtectedMemoryFeatures { VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( vk::Bool32 protectedMemory_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceProtectedMemoryFeatures( protectedMemory_ ) + : protectedMemory( protectedMemory_ ) {} + vk::PhysicalDeviceProtectedMemoryFeatures & operator=( vk::PhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceProtectedMemoryFeatures ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceProtectedMemoryFeatures( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceProtectedMemoryFeatures::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50682,52 +46956,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceProtectedMemoryFeatures::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures; + void* pNext = nullptr; + vk::Bool32 protectedMemory; }; static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceProtectedMemoryProperties { - struct PhysicalDeviceProtectedMemoryProperties - { - protected: - PhysicalDeviceProtectedMemoryProperties() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceProtectedMemoryProperties& operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties; - void* pNext = nullptr; - vk::Bool32 protectedNoFault; - }; - static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceProtectedMemoryProperties : public layout::PhysicalDeviceProtectedMemoryProperties - { - PhysicalDeviceProtectedMemoryProperties() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceProtectedMemoryProperties() + PhysicalDeviceProtectedMemoryProperties( vk::Bool32 protectedNoFault_ = 0 ) VULKAN_HPP_NOEXCEPT + : protectedNoFault( protectedNoFault_ ) {} + vk::PhysicalDeviceProtectedMemoryProperties & operator=( vk::PhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceProtectedMemoryProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceProtectedMemoryProperties( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceProtectedMemoryProperties& operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceProtectedMemoryProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50753,52 +47009,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceProtectedMemoryProperties::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties; + void* pNext = nullptr; + vk::Bool32 protectedNoFault; }; static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDevicePushDescriptorPropertiesKHR { - struct PhysicalDevicePushDescriptorPropertiesKHR - { - protected: - PhysicalDevicePushDescriptorPropertiesKHR() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR; - void* pNext = nullptr; - uint32_t maxPushDescriptors; - }; - static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDevicePushDescriptorPropertiesKHR : public layout::PhysicalDevicePushDescriptorPropertiesKHR - { - PhysicalDevicePushDescriptorPropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePushDescriptorPropertiesKHR() + PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxPushDescriptors( maxPushDescriptors_ ) {} + vk::PhysicalDevicePushDescriptorPropertiesKHR & operator=( vk::PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDevicePushDescriptorPropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDevicePushDescriptorPropertiesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDevicePushDescriptorPropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50824,59 +47062,48 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDevicePushDescriptorPropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR; + void* pNext = nullptr; + uint32_t maxPushDescriptors; }; static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceRayTracingPropertiesNV { - struct PhysicalDeviceRayTracingPropertiesNV - { - protected: - PhysicalDeviceRayTracingPropertiesNV() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceRayTracingPropertiesNV& operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV; - void* pNext = nullptr; - uint32_t shaderGroupHandleSize; - uint32_t maxRecursionDepth; - uint32_t maxShaderGroupStride; - uint32_t shaderGroupBaseAlignment; - uint64_t maxGeometryCount; - uint64_t maxInstanceCount; - uint64_t maxTriangleCount; - uint32_t maxDescriptorSetAccelerationStructures; - }; - static_assert( sizeof( PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceRayTracingPropertiesNV : public layout::PhysicalDeviceRayTracingPropertiesNV - { - PhysicalDeviceRayTracingPropertiesNV() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceRayTracingPropertiesNV() + PhysicalDeviceRayTracingPropertiesNV( uint32_t shaderGroupHandleSize_ = 0, + uint32_t maxRecursionDepth_ = 0, + uint32_t maxShaderGroupStride_ = 0, + uint32_t shaderGroupBaseAlignment_ = 0, + uint64_t maxGeometryCount_ = 0, + uint64_t maxInstanceCount_ = 0, + uint64_t maxTriangleCount_ = 0, + uint32_t maxDescriptorSetAccelerationStructures_ = 0 ) VULKAN_HPP_NOEXCEPT + : shaderGroupHandleSize( shaderGroupHandleSize_ ) + , maxRecursionDepth( maxRecursionDepth_ ) + , maxShaderGroupStride( maxShaderGroupStride_ ) + , shaderGroupBaseAlignment( shaderGroupBaseAlignment_ ) + , maxGeometryCount( maxGeometryCount_ ) + , maxInstanceCount( maxInstanceCount_ ) + , maxTriangleCount( maxTriangleCount_ ) + , maxDescriptorSetAccelerationStructures( maxDescriptorSetAccelerationStructures_ ) {} + vk::PhysicalDeviceRayTracingPropertiesNV & operator=( vk::PhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceRayTracingPropertiesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceRayTracingPropertiesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceRayTracingPropertiesNV& operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceRayTracingPropertiesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50909,53 +47136,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceRayTracingPropertiesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV; + void* pNext = nullptr; + uint32_t shaderGroupHandleSize; + uint32_t maxRecursionDepth; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint64_t maxGeometryCount; + 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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( vk::Bool32 representativeFragmentTest_ = 0 ) VULKAN_HPP_NOEXCEPT - : representativeFragmentTest( representativeFragmentTest_ ) - {} - - PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV; - void* pNext = nullptr; - vk::Bool32 representativeFragmentTest; - }; - static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV : public layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV + struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( vk::Bool32 representativeFragmentTest_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV( representativeFragmentTest_ ) + : representativeFragmentTest( representativeFragmentTest_ ) {} + vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV & operator=( vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -50993,56 +47208,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceRepresentativeFragmentTestFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV; + void* pNext = nullptr; + vk::Bool32 representativeFragmentTest; }; static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceSampleLocationsPropertiesEXT { - struct PhysicalDeviceSampleLocationsPropertiesEXT + PhysicalDeviceSampleLocationsPropertiesEXT( vk::SampleCountFlags sampleLocationSampleCounts_ = vk::SampleCountFlags(), + vk::Extent2D maxSampleLocationGridSize_ = vk::Extent2D(), + std::array const& sampleLocationCoordinateRange_ = { { 0 } }, + uint32_t sampleLocationSubPixelBits_ = 0, + vk::Bool32 variableSampleLocations_ = 0 ) VULKAN_HPP_NOEXCEPT + : sampleLocationSampleCounts( sampleLocationSampleCounts_ ) + , maxSampleLocationGridSize( maxSampleLocationGridSize_ ) + , sampleLocationCoordinateRange{} + , sampleLocationSubPixelBits( sampleLocationSubPixelBits_ ) + , variableSampleLocations( variableSampleLocations_ ) { - protected: - PhysicalDeviceSampleLocationsPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( sampleLocationCoordinateRange, sampleLocationCoordinateRange_ ); + } - PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSampleLocationsPropertiesEXT& operator=( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; - void* pNext = nullptr; - vk::SampleCountFlags sampleLocationSampleCounts; - vk::Extent2D maxSampleLocationGridSize; - float sampleLocationCoordinateRange[2]; - uint32_t sampleLocationSubPixelBits; - vk::Bool32 variableSampleLocations; - }; - static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSampleLocationsPropertiesEXT : public layout::PhysicalDeviceSampleLocationsPropertiesEXT - { - PhysicalDeviceSampleLocationsPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSampleLocationsPropertiesEXT() - {} + vk::PhysicalDeviceSampleLocationsPropertiesEXT & operator=( vk::PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSampleLocationsPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSampleLocationsPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSampleLocationsPropertiesEXT& operator=( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSampleLocationsPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51072,53 +47275,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSampleLocationsPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; + void* pNext = nullptr; + vk::SampleCountFlags sampleLocationSampleCounts; + vk::Extent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + vk::Bool32 variableSampleLocations; }; static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { - struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT - { - protected: - PhysicalDeviceSamplerFilterMinmaxPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSamplerFilterMinmaxPropertiesEXT& operator=( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT; - void* pNext = nullptr; - vk::Bool32 filterMinmaxSingleComponentFormats; - vk::Bool32 filterMinmaxImageComponentMapping; - }; - static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT : public layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT - { - PhysicalDeviceSamplerFilterMinmaxPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT() + PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( vk::Bool32 filterMinmaxSingleComponentFormats_ = 0, + vk::Bool32 filterMinmaxImageComponentMapping_ = 0 ) VULKAN_HPP_NOEXCEPT + : filterMinmaxSingleComponentFormats( filterMinmaxSingleComponentFormats_ ) + , filterMinmaxImageComponentMapping( filterMinmaxImageComponentMapping_ ) {} + vk::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT & operator=( vk::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSamplerFilterMinmaxPropertiesEXT& operator=( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51145,53 +47335,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + void* pNext = nullptr; + vk::Bool32 filterMinmaxSingleComponentFormats; + vk::Bool32 filterMinmaxImageComponentMapping; }; static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceSamplerYcbcrConversionFeatures - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( vk::Bool32 samplerYcbcrConversion_ = 0 ) VULKAN_HPP_NOEXCEPT - : samplerYcbcrConversion( samplerYcbcrConversion_ ) - {} - - PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures; - void* pNext = nullptr; - vk::Bool32 samplerYcbcrConversion; - }; - static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSamplerYcbcrConversionFeatures : public layout::PhysicalDeviceSamplerYcbcrConversionFeatures + struct PhysicalDeviceSamplerYcbcrConversionFeatures { VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( vk::Bool32 samplerYcbcrConversion_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSamplerYcbcrConversionFeatures( samplerYcbcrConversion_ ) + : samplerYcbcrConversion( samplerYcbcrConversion_ ) {} + vk::PhysicalDeviceSamplerYcbcrConversionFeatures & operator=( vk::PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSamplerYcbcrConversionFeatures ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSamplerYcbcrConversionFeatures( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSamplerYcbcrConversionFeatures::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51229,53 +47401,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSamplerYcbcrConversionFeatures::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures; + void* pNext = nullptr; + vk::Bool32 samplerYcbcrConversion; }; static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceScalarBlockLayoutFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeaturesEXT( vk::Bool32 scalarBlockLayout_ = 0 ) VULKAN_HPP_NOEXCEPT - : scalarBlockLayout( scalarBlockLayout_ ) - {} - - PhysicalDeviceScalarBlockLayoutFeaturesEXT( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 scalarBlockLayout; - }; - static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceScalarBlockLayoutFeaturesEXT : public layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT + struct PhysicalDeviceScalarBlockLayoutFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeaturesEXT( vk::Bool32 scalarBlockLayout_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT( scalarBlockLayout_ ) + : scalarBlockLayout( scalarBlockLayout_ ) {} + vk::PhysicalDeviceScalarBlockLayoutFeaturesEXT & operator=( vk::PhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceScalarBlockLayoutFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceScalarBlockLayoutFeaturesEXT( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51313,53 +47466,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceScalarBlockLayoutFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 scalarBlockLayout; }; static_assert( sizeof( PhysicalDeviceScalarBlockLayoutFeaturesEXT ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR( vk::Bool32 separateDepthStencilLayouts_ = 0 ) VULKAN_HPP_NOEXCEPT - : separateDepthStencilLayouts( separateDepthStencilLayouts_ ) - {} - - PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR( VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR& operator=( VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 separateDepthStencilLayouts; - }; - static_assert( sizeof( PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR ) == sizeof( VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR : public layout::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR + struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR( vk::Bool32 separateDepthStencilLayouts_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR( separateDepthStencilLayouts_ ) + : separateDepthStencilLayouts( separateDepthStencilLayouts_ ) {} + vk::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR & operator=( vk::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR( VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR& operator=( VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51397,57 +47531,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 separateDepthStencilLayouts; }; static_assert( sizeof( PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR ) == sizeof( VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderAtomicInt64FeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64FeaturesKHR( vk::Bool32 shaderBufferInt64Atomics_ = 0, - vk::Bool32 shaderSharedInt64Atomics_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ ) - , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ ) - {} - - PhysicalDeviceShaderAtomicInt64FeaturesKHR( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR; - void* pNext = nullptr; - vk::Bool32 shaderBufferInt64Atomics; - vk::Bool32 shaderSharedInt64Atomics; - }; - static_assert( sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderAtomicInt64FeaturesKHR : public layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR + struct PhysicalDeviceShaderAtomicInt64FeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64FeaturesKHR( vk::Bool32 shaderBufferInt64Atomics_ = 0, vk::Bool32 shaderSharedInt64Atomics_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR( shaderBufferInt64Atomics_, shaderSharedInt64Atomics_ ) + : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ ) + , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ ) {} + vk::PhysicalDeviceShaderAtomicInt64FeaturesKHR & operator=( vk::PhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderAtomicInt64FeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderAtomicInt64FeaturesKHR( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51492,57 +47605,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderAtomicInt64FeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR; + void* pNext = nullptr; + vk::Bool32 shaderBufferInt64Atomics; + vk::Bool32 shaderSharedInt64Atomics; }; static_assert( sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderClockFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( vk::Bool32 shaderSubgroupClock_ = 0, - vk::Bool32 shaderDeviceClock_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderSubgroupClock( shaderSubgroupClock_ ) - , shaderDeviceClock( shaderDeviceClock_ ) - {} - - PhysicalDeviceShaderClockFeaturesKHR( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderClockFeaturesKHR& operator=( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 shaderSubgroupClock; - vk::Bool32 shaderDeviceClock; - }; - static_assert( sizeof( PhysicalDeviceShaderClockFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderClockFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderClockFeaturesKHR : public layout::PhysicalDeviceShaderClockFeaturesKHR + struct PhysicalDeviceShaderClockFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( vk::Bool32 shaderSubgroupClock_ = 0, vk::Bool32 shaderDeviceClock_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderClockFeaturesKHR( shaderSubgroupClock_, shaderDeviceClock_ ) + : shaderSubgroupClock( shaderSubgroupClock_ ) + , shaderDeviceClock( shaderDeviceClock_ ) {} + vk::PhysicalDeviceShaderClockFeaturesKHR & operator=( vk::PhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderClockFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderClockFeaturesKHR( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderClockFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderClockFeaturesKHR& operator=( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderClockFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51587,53 +47680,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderClockFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 shaderSubgroupClock; + vk::Bool32 shaderDeviceClock; }; static_assert( sizeof( PhysicalDeviceShaderClockFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderClockFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceShaderCoreProperties2AMD { - struct PhysicalDeviceShaderCoreProperties2AMD - { - protected: - PhysicalDeviceShaderCoreProperties2AMD() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceShaderCoreProperties2AMD( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderCoreProperties2AMD& operator=( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD; - void* pNext = nullptr; - vk::ShaderCorePropertiesFlagsAMD shaderCoreFeatures; - uint32_t activeComputeUnitCount; - }; - static_assert( sizeof( PhysicalDeviceShaderCoreProperties2AMD ) == sizeof( VkPhysicalDeviceShaderCoreProperties2AMD ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderCoreProperties2AMD : public layout::PhysicalDeviceShaderCoreProperties2AMD - { - PhysicalDeviceShaderCoreProperties2AMD() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderCoreProperties2AMD() + PhysicalDeviceShaderCoreProperties2AMD( vk::ShaderCorePropertiesFlagsAMD shaderCoreFeatures_ = vk::ShaderCorePropertiesFlagsAMD(), + uint32_t activeComputeUnitCount_ = 0 ) VULKAN_HPP_NOEXCEPT + : shaderCoreFeatures( shaderCoreFeatures_ ) + , activeComputeUnitCount( activeComputeUnitCount_ ) {} + vk::PhysicalDeviceShaderCoreProperties2AMD & operator=( vk::PhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderCoreProperties2AMD ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderCoreProperties2AMD( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderCoreProperties2AMD( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderCoreProperties2AMD& operator=( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderCoreProperties2AMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51660,65 +47737,61 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderCoreProperties2AMD::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD; + void* pNext = nullptr; + vk::ShaderCorePropertiesFlagsAMD shaderCoreFeatures; + uint32_t activeComputeUnitCount; }; static_assert( sizeof( PhysicalDeviceShaderCoreProperties2AMD ) == sizeof( VkPhysicalDeviceShaderCoreProperties2AMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceShaderCorePropertiesAMD { - struct PhysicalDeviceShaderCorePropertiesAMD - { - protected: - PhysicalDeviceShaderCorePropertiesAMD() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceShaderCorePropertiesAMD( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderCorePropertiesAMD& operator=( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD; - void* pNext = nullptr; - uint32_t shaderEngineCount; - uint32_t shaderArraysPerEngineCount; - uint32_t computeUnitsPerShaderArray; - uint32_t simdPerComputeUnit; - uint32_t wavefrontsPerSimd; - uint32_t wavefrontSize; - uint32_t sgprsPerSimd; - uint32_t minSgprAllocation; - uint32_t maxSgprAllocation; - uint32_t sgprAllocationGranularity; - uint32_t vgprsPerSimd; - uint32_t minVgprAllocation; - uint32_t maxVgprAllocation; - uint32_t vgprAllocationGranularity; - }; - static_assert( sizeof( PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderCorePropertiesAMD : public layout::PhysicalDeviceShaderCorePropertiesAMD - { - PhysicalDeviceShaderCorePropertiesAMD() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderCorePropertiesAMD() + PhysicalDeviceShaderCorePropertiesAMD( uint32_t shaderEngineCount_ = 0, + uint32_t shaderArraysPerEngineCount_ = 0, + uint32_t computeUnitsPerShaderArray_ = 0, + uint32_t simdPerComputeUnit_ = 0, + uint32_t wavefrontsPerSimd_ = 0, + uint32_t wavefrontSize_ = 0, + uint32_t sgprsPerSimd_ = 0, + uint32_t minSgprAllocation_ = 0, + uint32_t maxSgprAllocation_ = 0, + uint32_t sgprAllocationGranularity_ = 0, + uint32_t vgprsPerSimd_ = 0, + uint32_t minVgprAllocation_ = 0, + uint32_t maxVgprAllocation_ = 0, + uint32_t vgprAllocationGranularity_ = 0 ) VULKAN_HPP_NOEXCEPT + : shaderEngineCount( shaderEngineCount_ ) + , shaderArraysPerEngineCount( shaderArraysPerEngineCount_ ) + , computeUnitsPerShaderArray( computeUnitsPerShaderArray_ ) + , simdPerComputeUnit( simdPerComputeUnit_ ) + , wavefrontsPerSimd( wavefrontsPerSimd_ ) + , wavefrontSize( wavefrontSize_ ) + , sgprsPerSimd( sgprsPerSimd_ ) + , minSgprAllocation( minSgprAllocation_ ) + , maxSgprAllocation( maxSgprAllocation_ ) + , sgprAllocationGranularity( sgprAllocationGranularity_ ) + , vgprsPerSimd( vgprsPerSimd_ ) + , minVgprAllocation( minVgprAllocation_ ) + , maxVgprAllocation( maxVgprAllocation_ ) + , vgprAllocationGranularity( vgprAllocationGranularity_ ) {} + vk::PhysicalDeviceShaderCorePropertiesAMD & operator=( vk::PhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderCorePropertiesAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderCorePropertiesAMD( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderCorePropertiesAMD( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderCorePropertiesAMD& operator=( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderCorePropertiesAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51757,53 +47830,47 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderCorePropertiesAMD::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD; + void* pNext = nullptr; + uint32_t shaderEngineCount; + uint32_t shaderArraysPerEngineCount; + uint32_t computeUnitsPerShaderArray; + uint32_t simdPerComputeUnit; + uint32_t wavefrontsPerSimd; + uint32_t wavefrontSize; + uint32_t sgprsPerSimd; + uint32_t minSgprAllocation; + uint32_t maxSgprAllocation; + uint32_t sgprAllocationGranularity; + uint32_t vgprsPerSimd; + 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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( vk::Bool32 shaderDemoteToHelperInvocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderDemoteToHelperInvocation( shaderDemoteToHelperInvocation_ ) - {} - - PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& operator=( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 shaderDemoteToHelperInvocation; - }; - static_assert( sizeof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT : public layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT + struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( vk::Bool32 shaderDemoteToHelperInvocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( shaderDemoteToHelperInvocation_ ) + : shaderDemoteToHelperInvocation( shaderDemoteToHelperInvocation_ ) {} + vk::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT & operator=( vk::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& operator=( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51841,53 +47908,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 shaderDemoteToHelperInvocation; }; static_assert( sizeof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderDrawParametersFeatures - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( vk::Bool32 shaderDrawParameters_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderDrawParameters( shaderDrawParameters_ ) - {} - - PhysicalDeviceShaderDrawParametersFeatures( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderDrawParametersFeatures& operator=( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures; - void* pNext = nullptr; - vk::Bool32 shaderDrawParameters; - }; - static_assert( sizeof( PhysicalDeviceShaderDrawParametersFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParametersFeatures ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderDrawParametersFeatures : public layout::PhysicalDeviceShaderDrawParametersFeatures + struct PhysicalDeviceShaderDrawParametersFeatures { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( vk::Bool32 shaderDrawParameters_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderDrawParametersFeatures( shaderDrawParameters_ ) + : shaderDrawParameters( shaderDrawParameters_ ) {} + vk::PhysicalDeviceShaderDrawParametersFeatures & operator=( vk::PhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderDrawParametersFeatures ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderDrawParametersFeatures( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderDrawParametersFeatures( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderDrawParametersFeatures& operator=( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderDrawParametersFeatures::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -51925,57 +47973,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderDrawParametersFeatures::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures; + void* pNext = nullptr; + vk::Bool32 shaderDrawParameters; }; static_assert( sizeof( PhysicalDeviceShaderDrawParametersFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParametersFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderFloat16Int8FeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8FeaturesKHR( vk::Bool32 shaderFloat16_ = 0, - vk::Bool32 shaderInt8_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderFloat16( shaderFloat16_ ) - , shaderInt8( shaderInt8_ ) - {} - - PhysicalDeviceShaderFloat16Int8FeaturesKHR( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderFloat16Int8FeaturesKHR; - void* pNext = nullptr; - vk::Bool32 shaderFloat16; - vk::Bool32 shaderInt8; - }; - static_assert( sizeof( PhysicalDeviceShaderFloat16Int8FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderFloat16Int8FeaturesKHR : public layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR + struct PhysicalDeviceShaderFloat16Int8FeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8FeaturesKHR( vk::Bool32 shaderFloat16_ = 0, vk::Bool32 shaderInt8_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR( shaderFloat16_, shaderInt8_ ) + : shaderFloat16( shaderFloat16_ ) + , shaderInt8( shaderInt8_ ) {} + vk::PhysicalDeviceShaderFloat16Int8FeaturesKHR & operator=( vk::PhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderFloat16Int8FeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderFloat16Int8FeaturesKHR( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52020,53 +48047,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderFloat16Int8FeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderFloat16Int8FeaturesKHR; + void* pNext = nullptr; + vk::Bool32 shaderFloat16; + vk::Bool32 shaderInt8; }; static_assert( sizeof( PhysicalDeviceShaderFloat16Int8FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderImageFootprintFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( vk::Bool32 imageFootprint_ = 0 ) VULKAN_HPP_NOEXCEPT - : imageFootprint( imageFootprint_ ) - {} - - PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV; - void* pNext = nullptr; - vk::Bool32 imageFootprint; - }; - static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderImageFootprintFeaturesNV : public layout::PhysicalDeviceShaderImageFootprintFeaturesNV + struct PhysicalDeviceShaderImageFootprintFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( vk::Bool32 imageFootprint_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderImageFootprintFeaturesNV( imageFootprint_ ) + : imageFootprint( imageFootprint_ ) {} + vk::PhysicalDeviceShaderImageFootprintFeaturesNV & operator=( vk::PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderImageFootprintFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderImageFootprintFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderImageFootprintFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52104,53 +48113,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderImageFootprintFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV; + void* pNext = nullptr; + vk::Bool32 imageFootprint; }; static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( vk::Bool32 shaderIntegerFunctions2_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderIntegerFunctions2( shaderIntegerFunctions2_ ) - {} - - PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; - void* pNext = nullptr; - vk::Bool32 shaderIntegerFunctions2; - }; - static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL : public layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL + struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( vk::Bool32 shaderIntegerFunctions2_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( shaderIntegerFunctions2_ ) + : shaderIntegerFunctions2( shaderIntegerFunctions2_ ) {} + vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & operator=( vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52188,53 +48178,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + void* pNext = nullptr; + vk::Bool32 shaderIntegerFunctions2; }; static_assert( sizeof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) == sizeof( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderSMBuiltinsFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( vk::Bool32 shaderSMBuiltins_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderSMBuiltins( shaderSMBuiltins_ ) - {} - - PhysicalDeviceShaderSMBuiltinsFeaturesNV( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV; - void* pNext = nullptr; - vk::Bool32 shaderSMBuiltins; - }; - static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderSMBuiltinsFeaturesNV : public layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV + struct PhysicalDeviceShaderSMBuiltinsFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( vk::Bool32 shaderSMBuiltins_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV( shaderSMBuiltins_ ) + : shaderSMBuiltins( shaderSMBuiltins_ ) {} + vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV & operator=( vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderSMBuiltinsFeaturesNV( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52272,53 +48243,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderSMBuiltinsFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV; + void* pNext = nullptr; + vk::Bool32 shaderSMBuiltins; }; static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceShaderSMBuiltinsPropertiesNV { - struct PhysicalDeviceShaderSMBuiltinsPropertiesNV - { - protected: - PhysicalDeviceShaderSMBuiltinsPropertiesNV() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceShaderSMBuiltinsPropertiesNV( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV; - void* pNext = nullptr; - uint32_t shaderSMCount; - uint32_t shaderWarpsPerSM; - }; - static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsPropertiesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderSMBuiltinsPropertiesNV : public layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV - { - PhysicalDeviceShaderSMBuiltinsPropertiesNV() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV() + PhysicalDeviceShaderSMBuiltinsPropertiesNV( uint32_t shaderSMCount_ = 0, + uint32_t shaderWarpsPerSM_ = 0 ) VULKAN_HPP_NOEXCEPT + : shaderSMCount( shaderSMCount_ ) + , shaderWarpsPerSM( shaderWarpsPerSM_ ) {} + vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV & operator=( vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderSMBuiltinsPropertiesNV( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52345,53 +48299,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderSMBuiltinsPropertiesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV; + void* pNext = nullptr; + uint32_t shaderSMCount; + uint32_t shaderWarpsPerSM; }; static_assert( sizeof( PhysicalDeviceShaderSMBuiltinsPropertiesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( vk::Bool32 shaderSubgroupExtendedTypes_ = 0 ) VULKAN_HPP_NOEXCEPT - : shaderSubgroupExtendedTypes( shaderSubgroupExtendedTypes_ ) - {} - - PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR& operator=( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 shaderSubgroupExtendedTypes; - }; - static_assert( sizeof( PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR : public layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR + struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( vk::Bool32 shaderSubgroupExtendedTypes_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( shaderSubgroupExtendedTypes_ ) + : shaderSubgroupExtendedTypes( shaderSubgroupExtendedTypes_ ) {} + vk::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR & operator=( vk::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR& operator=( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52429,57 +48365,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 shaderSubgroupExtendedTypes; }; static_assert( sizeof( PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceShadingRateImageFeaturesNV - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( vk::Bool32 shadingRateImage_ = 0, - vk::Bool32 shadingRateCoarseSampleOrder_ = 0 ) VULKAN_HPP_NOEXCEPT - : shadingRateImage( shadingRateImage_ ) - , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ ) - {} - - PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV; - void* pNext = nullptr; - vk::Bool32 shadingRateImage; - vk::Bool32 shadingRateCoarseSampleOrder; - }; - static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShadingRateImageFeaturesNV : public layout::PhysicalDeviceShadingRateImageFeaturesNV + struct PhysicalDeviceShadingRateImageFeaturesNV { VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( vk::Bool32 shadingRateImage_ = 0, vk::Bool32 shadingRateCoarseSampleOrder_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShadingRateImageFeaturesNV( shadingRateImage_, shadingRateCoarseSampleOrder_ ) + : shadingRateImage( shadingRateImage_ ) + , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ ) {} + vk::PhysicalDeviceShadingRateImageFeaturesNV & operator=( vk::PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShadingRateImageFeaturesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShadingRateImageFeaturesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShadingRateImageFeaturesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52524,54 +48439,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShadingRateImageFeaturesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV; + void* pNext = nullptr; + vk::Bool32 shadingRateImage; + vk::Bool32 shadingRateCoarseSampleOrder; }; static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceShadingRateImagePropertiesNV { - struct PhysicalDeviceShadingRateImagePropertiesNV - { - protected: - PhysicalDeviceShadingRateImagePropertiesNV() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceShadingRateImagePropertiesNV( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceShadingRateImagePropertiesNV& operator=( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV; - void* pNext = nullptr; - vk::Extent2D shadingRateTexelSize; - uint32_t shadingRatePaletteSize; - uint32_t shadingRateMaxCoarseSamples; - }; - static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceShadingRateImagePropertiesNV : public layout::PhysicalDeviceShadingRateImagePropertiesNV - { - PhysicalDeviceShadingRateImagePropertiesNV() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShadingRateImagePropertiesNV() + PhysicalDeviceShadingRateImagePropertiesNV( vk::Extent2D shadingRateTexelSize_ = vk::Extent2D(), + uint32_t shadingRatePaletteSize_ = 0, + uint32_t shadingRateMaxCoarseSamples_ = 0 ) VULKAN_HPP_NOEXCEPT + : shadingRateTexelSize( shadingRateTexelSize_ ) + , shadingRatePaletteSize( shadingRatePaletteSize_ ) + , shadingRateMaxCoarseSamples( shadingRateMaxCoarseSamples_ ) {} + vk::PhysicalDeviceShadingRateImagePropertiesNV & operator=( vk::PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceShadingRateImagePropertiesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceShadingRateImagePropertiesNV( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceShadingRateImagePropertiesNV( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceShadingRateImagePropertiesNV& operator=( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceShadingRateImagePropertiesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52599,69 +48499,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceShadingRateImagePropertiesNV::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV; + void* pNext = nullptr; + vk::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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceSparseImageFormatInfo2 - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined, - vk::ImageType type_ = vk::ImageType::e1D, - vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1, - vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(), - vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal ) VULKAN_HPP_NOEXCEPT - : format( format_ ) - , type( type_ ) - , samples( samples_ ) - , usage( usage_ ) - , tiling( tiling_ ) - {} - - PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2; - const void* pNext = nullptr; - vk::Format format; - vk::ImageType type; - vk::SampleCountFlagBits samples; - vk::ImageUsageFlags usage; - vk::ImageTiling tiling; - }; - static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSparseImageFormatInfo2 : public layout::PhysicalDeviceSparseImageFormatInfo2 + struct PhysicalDeviceSparseImageFormatInfo2 { VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( vk::Format format_ = vk::Format::eUndefined, vk::ImageType type_ = vk::ImageType::e1D, vk::SampleCountFlagBits samples_ = vk::SampleCountFlagBits::e1, vk::ImageUsageFlags usage_ = vk::ImageUsageFlags(), vk::ImageTiling tiling_ = vk::ImageTiling::eOptimal ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSparseImageFormatInfo2( format_, type_, samples_, usage_, tiling_ ) + : format( format_ ) + , type( type_ ) + , samples( samples_ ) + , usage( usage_ ) + , tiling( tiling_ ) {} + vk::PhysicalDeviceSparseImageFormatInfo2 & operator=( vk::PhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSparseImageFormatInfo2 ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSparseImageFormatInfo2( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSparseImageFormatInfo2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52727,55 +48602,44 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSparseImageFormatInfo2::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2; + const void* pNext = nullptr; + vk::Format format; + vk::ImageType type; + vk::SampleCountFlagBits samples; + vk::ImageUsageFlags usage; + vk::ImageTiling tiling; }; static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceSubgroupProperties { - struct PhysicalDeviceSubgroupProperties - { - protected: - PhysicalDeviceSubgroupProperties() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceSubgroupProperties( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSubgroupProperties& operator=( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties; - void* pNext = nullptr; - uint32_t subgroupSize; - vk::ShaderStageFlags supportedStages; - vk::SubgroupFeatureFlags supportedOperations; - vk::Bool32 quadOperationsInAllStages; - }; - static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSubgroupProperties : public layout::PhysicalDeviceSubgroupProperties - { - PhysicalDeviceSubgroupProperties() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSubgroupProperties() + PhysicalDeviceSubgroupProperties( uint32_t subgroupSize_ = 0, + vk::ShaderStageFlags supportedStages_ = vk::ShaderStageFlags(), + vk::SubgroupFeatureFlags supportedOperations_ = vk::SubgroupFeatureFlags(), + vk::Bool32 quadOperationsInAllStages_ = 0 ) VULKAN_HPP_NOEXCEPT + : subgroupSize( subgroupSize_ ) + , supportedStages( supportedStages_ ) + , supportedOperations( supportedOperations_ ) + , quadOperationsInAllStages( quadOperationsInAllStages_ ) {} + vk::PhysicalDeviceSubgroupProperties & operator=( vk::PhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSubgroupProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSubgroupProperties( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSubgroupProperties( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSubgroupProperties& operator=( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSubgroupProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52804,57 +48668,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSubgroupProperties::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties; + void* pNext = nullptr; + uint32_t subgroupSize; + vk::ShaderStageFlags supportedStages; + vk::SubgroupFeatureFlags supportedOperations; + vk::Bool32 quadOperationsInAllStages; }; static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceSubgroupSizeControlFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeaturesEXT( vk::Bool32 subgroupSizeControl_ = 0, - vk::Bool32 computeFullSubgroups_ = 0 ) VULKAN_HPP_NOEXCEPT - : subgroupSizeControl( subgroupSizeControl_ ) - , computeFullSubgroups( computeFullSubgroups_ ) - {} - - PhysicalDeviceSubgroupSizeControlFeaturesEXT( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 subgroupSizeControl; - vk::Bool32 computeFullSubgroups; - }; - static_assert( sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSubgroupSizeControlFeaturesEXT : public layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT + struct PhysicalDeviceSubgroupSizeControlFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeaturesEXT( vk::Bool32 subgroupSizeControl_ = 0, vk::Bool32 computeFullSubgroups_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT( subgroupSizeControl_, computeFullSubgroups_ ) + : subgroupSizeControl( subgroupSizeControl_ ) + , computeFullSubgroups( computeFullSubgroups_ ) {} + vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT & operator=( vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSubgroupSizeControlFeaturesEXT( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52899,55 +48745,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSubgroupSizeControlFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 subgroupSizeControl; + vk::Bool32 computeFullSubgroups; }; static_assert( sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceSubgroupSizeControlPropertiesEXT { - struct PhysicalDeviceSubgroupSizeControlPropertiesEXT - { - protected: - PhysicalDeviceSubgroupSizeControlPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceSubgroupSizeControlPropertiesEXT( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSubgroupSizeControlPropertiesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT; - void* pNext = nullptr; - uint32_t minSubgroupSize; - uint32_t maxSubgroupSize; - uint32_t maxComputeWorkgroupSubgroups; - vk::ShaderStageFlags requiredSubgroupSizeStages; - }; - static_assert( sizeof( PhysicalDeviceSubgroupSizeControlPropertiesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSubgroupSizeControlPropertiesEXT : public layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT - { - PhysicalDeviceSubgroupSizeControlPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT() + PhysicalDeviceSubgroupSizeControlPropertiesEXT( uint32_t minSubgroupSize_ = 0, + uint32_t maxSubgroupSize_ = 0, + uint32_t maxComputeWorkgroupSubgroups_ = 0, + vk::ShaderStageFlags requiredSubgroupSizeStages_ = vk::ShaderStageFlags() ) VULKAN_HPP_NOEXCEPT + : minSubgroupSize( minSubgroupSize_ ) + , maxSubgroupSize( maxSubgroupSize_ ) + , maxComputeWorkgroupSubgroups( maxComputeWorkgroupSubgroups_ ) + , requiredSubgroupSizeStages( requiredSubgroupSizeStages_ ) {} + vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT & operator=( vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSubgroupSizeControlPropertiesEXT( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSubgroupSizeControlPropertiesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -52976,53 +48808,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSubgroupSizeControlPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlPropertiesEXT; + void* pNext = nullptr; + uint32_t minSubgroupSize; + uint32_t maxSubgroupSize; + uint32_t maxComputeWorkgroupSubgroups; + vk::ShaderStageFlags requiredSubgroupSizeStages; }; static_assert( sizeof( PhysicalDeviceSubgroupSizeControlPropertiesEXT ) == sizeof( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceSurfaceInfo2KHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( vk::SurfaceKHR surface_ = vk::SurfaceKHR() ) VULKAN_HPP_NOEXCEPT - : surface( surface_ ) - {} - - PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; - const void* pNext = nullptr; - vk::SurfaceKHR surface; - }; - static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceSurfaceInfo2KHR : public layout::PhysicalDeviceSurfaceInfo2KHR + struct PhysicalDeviceSurfaceInfo2KHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( vk::SurfaceKHR surface_ = vk::SurfaceKHR() ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSurfaceInfo2KHR( surface_ ) + : surface( surface_ ) {} + vk::PhysicalDeviceSurfaceInfo2KHR & operator=( vk::PhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceSurfaceInfo2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceSurfaceInfo2KHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceSurfaceInfo2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53060,53 +48876,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceSurfaceInfo2KHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; + const void* pNext = nullptr; + vk::SurfaceKHR surface; }; static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( vk::Bool32 texelBufferAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT - : texelBufferAlignment( texelBufferAlignment_ ) - {} - - PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 texelBufferAlignment; - }; - static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT : public layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT + struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( vk::Bool32 texelBufferAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT( texelBufferAlignment_ ) + : texelBufferAlignment( texelBufferAlignment_ ) {} + vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT & operator=( vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53144,55 +48941,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceTexelBufferAlignmentFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 texelBufferAlignment; }; static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT { - struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT - { - protected: - PhysicalDeviceTexelBufferAlignmentPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceTexelBufferAlignmentPropertiesEXT( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceTexelBufferAlignmentPropertiesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT; - void* pNext = nullptr; - vk::DeviceSize storageTexelBufferOffsetAlignmentBytes; - vk::Bool32 storageTexelBufferOffsetSingleTexelAlignment; - vk::DeviceSize uniformTexelBufferOffsetAlignmentBytes; - vk::Bool32 uniformTexelBufferOffsetSingleTexelAlignment; - }; - static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT : public layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT - { - PhysicalDeviceTexelBufferAlignmentPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT() + PhysicalDeviceTexelBufferAlignmentPropertiesEXT( vk::DeviceSize storageTexelBufferOffsetAlignmentBytes_ = 0, + vk::Bool32 storageTexelBufferOffsetSingleTexelAlignment_ = 0, + vk::DeviceSize uniformTexelBufferOffsetAlignmentBytes_ = 0, + vk::Bool32 uniformTexelBufferOffsetSingleTexelAlignment_ = 0 ) VULKAN_HPP_NOEXCEPT + : storageTexelBufferOffsetAlignmentBytes( storageTexelBufferOffsetAlignmentBytes_ ) + , storageTexelBufferOffsetSingleTexelAlignment( storageTexelBufferOffsetSingleTexelAlignment_ ) + , uniformTexelBufferOffsetAlignmentBytes( uniformTexelBufferOffsetAlignmentBytes_ ) + , uniformTexelBufferOffsetSingleTexelAlignment( uniformTexelBufferOffsetSingleTexelAlignment_ ) {} + vk::PhysicalDeviceTexelBufferAlignmentPropertiesEXT & operator=( vk::PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceTexelBufferAlignmentPropertiesEXT( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceTexelBufferAlignmentPropertiesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53221,57 +49003,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceTexelBufferAlignmentPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentPropertiesEXT; + void* pNext = nullptr; + vk::DeviceSize storageTexelBufferOffsetAlignmentBytes; + vk::Bool32 storageTexelBufferOffsetSingleTexelAlignment; + vk::DeviceSize uniformTexelBufferOffsetAlignmentBytes; + vk::Bool32 uniformTexelBufferOffsetSingleTexelAlignment; }; static_assert( sizeof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) == sizeof( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( vk::Bool32 textureCompressionASTC_HDR_ = 0 ) VULKAN_HPP_NOEXCEPT - : textureCompressionASTC_HDR( textureCompressionASTC_HDR_ ) - {} - - PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT; - const void* pNext = nullptr; - vk::Bool32 textureCompressionASTC_HDR; - }; - static_assert( sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) == sizeof( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT : public layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT + struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( vk::Bool32 textureCompressionASTC_HDR_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( textureCompressionASTC_HDR_ ) + : textureCompressionASTC_HDR( textureCompressionASTC_HDR_ ) {} - PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( rhs ) - {} - - PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & operator=( vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::operator=(rhs); + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) - sizeof( vk::StructureType ) ); return *this; } - PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT + PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } + + PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast(&rhs); + return *this; + } + + PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & setPNext( void* pNext_ ) VULKAN_HPP_NOEXCEPT { pNext = pNext_; return *this; @@ -53305,53 +49071,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 textureCompressionASTC_HDR; }; static_assert( sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) == sizeof( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceTimelineSemaphoreFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeaturesKHR( vk::Bool32 timelineSemaphore_ = 0 ) VULKAN_HPP_NOEXCEPT - : timelineSemaphore( timelineSemaphore_ ) - {} - - PhysicalDeviceTimelineSemaphoreFeaturesKHR( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceTimelineSemaphoreFeaturesKHR& operator=( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 timelineSemaphore; - }; - static_assert( sizeof( PhysicalDeviceTimelineSemaphoreFeaturesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceTimelineSemaphoreFeaturesKHR : public layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR + struct PhysicalDeviceTimelineSemaphoreFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeaturesKHR( vk::Bool32 timelineSemaphore_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR( timelineSemaphore_ ) + : timelineSemaphore( timelineSemaphore_ ) {} + vk::PhysicalDeviceTimelineSemaphoreFeaturesKHR & operator=( vk::PhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTimelineSemaphoreFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceTimelineSemaphoreFeaturesKHR( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceTimelineSemaphoreFeaturesKHR& operator=( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53389,52 +49136,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceTimelineSemaphoreFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 timelineSemaphore; }; static_assert( sizeof( PhysicalDeviceTimelineSemaphoreFeaturesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceTimelineSemaphorePropertiesKHR { - struct PhysicalDeviceTimelineSemaphorePropertiesKHR - { - protected: - PhysicalDeviceTimelineSemaphorePropertiesKHR() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceTimelineSemaphorePropertiesKHR( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceTimelineSemaphorePropertiesKHR& operator=( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphorePropertiesKHR; - void* pNext = nullptr; - uint64_t maxTimelineSemaphoreValueDifference; - }; - static_assert( sizeof( PhysicalDeviceTimelineSemaphorePropertiesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphorePropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceTimelineSemaphorePropertiesKHR : public layout::PhysicalDeviceTimelineSemaphorePropertiesKHR - { - PhysicalDeviceTimelineSemaphorePropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTimelineSemaphorePropertiesKHR() + PhysicalDeviceTimelineSemaphorePropertiesKHR( uint64_t maxTimelineSemaphoreValueDifference_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxTimelineSemaphoreValueDifference( maxTimelineSemaphoreValueDifference_ ) {} + vk::PhysicalDeviceTimelineSemaphorePropertiesKHR & operator=( vk::PhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTimelineSemaphorePropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceTimelineSemaphorePropertiesKHR( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTimelineSemaphorePropertiesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceTimelineSemaphorePropertiesKHR& operator=( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceTimelineSemaphorePropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53460,57 +49189,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceTimelineSemaphorePropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphorePropertiesKHR; + void* pNext = nullptr; + uint64_t maxTimelineSemaphoreValueDifference; }; static_assert( sizeof( PhysicalDeviceTimelineSemaphorePropertiesKHR ) == sizeof( VkPhysicalDeviceTimelineSemaphorePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceTransformFeedbackFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( vk::Bool32 transformFeedback_ = 0, - vk::Bool32 geometryStreams_ = 0 ) VULKAN_HPP_NOEXCEPT - : transformFeedback( transformFeedback_ ) - , geometryStreams( geometryStreams_ ) - {} - - PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 transformFeedback; - vk::Bool32 geometryStreams; - }; - static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceTransformFeedbackFeaturesEXT : public layout::PhysicalDeviceTransformFeedbackFeaturesEXT + struct PhysicalDeviceTransformFeedbackFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( vk::Bool32 transformFeedback_ = 0, vk::Bool32 geometryStreams_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTransformFeedbackFeaturesEXT( transformFeedback_, geometryStreams_ ) + : transformFeedback( transformFeedback_ ) + , geometryStreams( geometryStreams_ ) {} + vk::PhysicalDeviceTransformFeedbackFeaturesEXT & operator=( vk::PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTransformFeedbackFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTransformFeedbackFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceTransformFeedbackFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53555,61 +49263,53 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceTransformFeedbackFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 transformFeedback; + vk::Bool32 geometryStreams; }; static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceTransformFeedbackPropertiesEXT { - struct PhysicalDeviceTransformFeedbackPropertiesEXT - { - protected: - PhysicalDeviceTransformFeedbackPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceTransformFeedbackPropertiesEXT( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceTransformFeedbackPropertiesEXT& operator=( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT; - void* pNext = nullptr; - uint32_t maxTransformFeedbackStreams; - uint32_t maxTransformFeedbackBuffers; - vk::DeviceSize maxTransformFeedbackBufferSize; - uint32_t maxTransformFeedbackStreamDataSize; - uint32_t maxTransformFeedbackBufferDataSize; - uint32_t maxTransformFeedbackBufferDataStride; - vk::Bool32 transformFeedbackQueries; - vk::Bool32 transformFeedbackStreamsLinesTriangles; - vk::Bool32 transformFeedbackRasterizationStreamSelect; - vk::Bool32 transformFeedbackDraw; - }; - static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceTransformFeedbackPropertiesEXT : public layout::PhysicalDeviceTransformFeedbackPropertiesEXT - { - PhysicalDeviceTransformFeedbackPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTransformFeedbackPropertiesEXT() + PhysicalDeviceTransformFeedbackPropertiesEXT( uint32_t maxTransformFeedbackStreams_ = 0, + uint32_t maxTransformFeedbackBuffers_ = 0, + vk::DeviceSize maxTransformFeedbackBufferSize_ = 0, + uint32_t maxTransformFeedbackStreamDataSize_ = 0, + uint32_t maxTransformFeedbackBufferDataSize_ = 0, + uint32_t maxTransformFeedbackBufferDataStride_ = 0, + vk::Bool32 transformFeedbackQueries_ = 0, + vk::Bool32 transformFeedbackStreamsLinesTriangles_ = 0, + vk::Bool32 transformFeedbackRasterizationStreamSelect_ = 0, + vk::Bool32 transformFeedbackDraw_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxTransformFeedbackStreams( maxTransformFeedbackStreams_ ) + , maxTransformFeedbackBuffers( maxTransformFeedbackBuffers_ ) + , maxTransformFeedbackBufferSize( maxTransformFeedbackBufferSize_ ) + , maxTransformFeedbackStreamDataSize( maxTransformFeedbackStreamDataSize_ ) + , maxTransformFeedbackBufferDataSize( maxTransformFeedbackBufferDataSize_ ) + , maxTransformFeedbackBufferDataStride( maxTransformFeedbackBufferDataStride_ ) + , transformFeedbackQueries( transformFeedbackQueries_ ) + , transformFeedbackStreamsLinesTriangles( transformFeedbackStreamsLinesTriangles_ ) + , transformFeedbackRasterizationStreamSelect( transformFeedbackRasterizationStreamSelect_ ) + , transformFeedbackDraw( transformFeedbackDraw_ ) {} + vk::PhysicalDeviceTransformFeedbackPropertiesEXT & operator=( vk::PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTransformFeedbackPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceTransformFeedbackPropertiesEXT( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceTransformFeedbackPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceTransformFeedbackPropertiesEXT& operator=( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceTransformFeedbackPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53644,53 +49344,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceTransformFeedbackPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT; + void* pNext = nullptr; + uint32_t maxTransformFeedbackStreams; + uint32_t maxTransformFeedbackBuffers; + vk::DeviceSize maxTransformFeedbackBufferSize; + uint32_t maxTransformFeedbackStreamDataSize; + uint32_t maxTransformFeedbackBufferDataSize; + uint32_t maxTransformFeedbackBufferDataStride; + vk::Bool32 transformFeedbackQueries; + vk::Bool32 transformFeedbackStreamsLinesTriangles; + vk::Bool32 transformFeedbackRasterizationStreamSelect; + vk::Bool32 transformFeedbackDraw; }; static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( vk::Bool32 uniformBufferStandardLayout_ = 0 ) VULKAN_HPP_NOEXCEPT - : uniformBufferStandardLayout( uniformBufferStandardLayout_ ) - {} - - PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& operator=( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 uniformBufferStandardLayout; - }; - static_assert( sizeof( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) == sizeof( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR : public layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR + struct PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( vk::Bool32 uniformBufferStandardLayout_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( uniformBufferStandardLayout_ ) + : uniformBufferStandardLayout( uniformBufferStandardLayout_ ) {} + vk::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR & operator=( vk::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& operator=( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53728,57 +49418,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 uniformBufferStandardLayout; }; static_assert( sizeof( PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ) == sizeof( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceVariablePointersFeatures - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( vk::Bool32 variablePointersStorageBuffer_ = 0, - vk::Bool32 variablePointers_ = 0 ) VULKAN_HPP_NOEXCEPT - : variablePointersStorageBuffer( variablePointersStorageBuffer_ ) - , variablePointers( variablePointers_ ) - {} - - PhysicalDeviceVariablePointersFeatures( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceVariablePointersFeatures& operator=( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceVariablePointersFeatures; - void* pNext = nullptr; - vk::Bool32 variablePointersStorageBuffer; - vk::Bool32 variablePointers; - }; - static_assert( sizeof( PhysicalDeviceVariablePointersFeatures ) == sizeof( VkPhysicalDeviceVariablePointersFeatures ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceVariablePointersFeatures : public layout::PhysicalDeviceVariablePointersFeatures + struct PhysicalDeviceVariablePointersFeatures { VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( vk::Bool32 variablePointersStorageBuffer_ = 0, vk::Bool32 variablePointers_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVariablePointersFeatures( variablePointersStorageBuffer_, variablePointers_ ) + : variablePointersStorageBuffer( variablePointersStorageBuffer_ ) + , variablePointers( variablePointers_ ) {} + vk::PhysicalDeviceVariablePointersFeatures & operator=( vk::PhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceVariablePointersFeatures ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceVariablePointersFeatures( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVariablePointersFeatures( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceVariablePointersFeatures& operator=( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceVariablePointersFeatures::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53823,57 +49492,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceVariablePointersFeatures::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceVariablePointersFeatures; + void* pNext = nullptr; + vk::Bool32 variablePointersStorageBuffer; + vk::Bool32 variablePointers; }; static_assert( sizeof( PhysicalDeviceVariablePointersFeatures ) == sizeof( VkPhysicalDeviceVariablePointersFeatures ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vk::Bool32 vertexAttributeInstanceRateDivisor_ = 0, - vk::Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 ) VULKAN_HPP_NOEXCEPT - : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ ) - , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ ) - {} - - PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 vertexAttributeInstanceRateDivisor; - vk::Bool32 vertexAttributeInstanceRateZeroDivisor; - }; - static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT : public layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT + struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vk::Bool32 vertexAttributeInstanceRateDivisor_ = 0, vk::Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT( vertexAttributeInstanceRateDivisor_, vertexAttributeInstanceRateZeroDivisor_ ) + : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ ) + , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ ) {} + vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT & operator=( vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceVertexAttributeDivisorFeaturesEXT( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53918,52 +49567,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceVertexAttributeDivisorFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 vertexAttributeInstanceRateDivisor; + vk::Bool32 vertexAttributeInstanceRateZeroDivisor; }; static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { - struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT - { - protected: - PhysicalDeviceVertexAttributeDivisorPropertiesEXT() VULKAN_HPP_NOEXCEPT - {} - - PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT; - void* pNext = nullptr; - uint32_t maxVertexAttribDivisor; - }; - static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT : public layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT - { - PhysicalDeviceVertexAttributeDivisorPropertiesEXT() VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT() + PhysicalDeviceVertexAttributeDivisorPropertiesEXT( uint32_t maxVertexAttribDivisor_ = 0 ) VULKAN_HPP_NOEXCEPT + : maxVertexAttribDivisor( maxVertexAttribDivisor_ ) {} + vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT & operator=( vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -53989,61 +49621,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceVertexAttributeDivisorPropertiesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT; + void* pNext = nullptr; + uint32_t maxVertexAttribDivisor; }; static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceVulkanMemoryModelFeaturesKHR - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeaturesKHR( vk::Bool32 vulkanMemoryModel_ = 0, - vk::Bool32 vulkanMemoryModelDeviceScope_ = 0, - vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = 0 ) VULKAN_HPP_NOEXCEPT - : vulkanMemoryModel( vulkanMemoryModel_ ) - , vulkanMemoryModelDeviceScope( vulkanMemoryModelDeviceScope_ ) - , vulkanMemoryModelAvailabilityVisibilityChains( vulkanMemoryModelAvailabilityVisibilityChains_ ) - {} - - PhysicalDeviceVulkanMemoryModelFeaturesKHR( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceVulkanMemoryModelFeaturesKHR& operator=( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR; - void* pNext = nullptr; - vk::Bool32 vulkanMemoryModel; - vk::Bool32 vulkanMemoryModelDeviceScope; - vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains; - }; - static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceVulkanMemoryModelFeaturesKHR : public layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR + struct PhysicalDeviceVulkanMemoryModelFeaturesKHR { VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeaturesKHR( vk::Bool32 vulkanMemoryModel_ = 0, vk::Bool32 vulkanMemoryModelDeviceScope_ = 0, vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR( vulkanMemoryModel_, vulkanMemoryModelDeviceScope_, vulkanMemoryModelAvailabilityVisibilityChains_ ) + : vulkanMemoryModel( vulkanMemoryModel_ ) + , vulkanMemoryModelDeviceScope( vulkanMemoryModelDeviceScope_ ) + , vulkanMemoryModelAvailabilityVisibilityChains( vulkanMemoryModelAvailabilityVisibilityChains_ ) {} + vk::PhysicalDeviceVulkanMemoryModelFeaturesKHR & operator=( vk::PhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceVulkanMemoryModelFeaturesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceVulkanMemoryModelFeaturesKHR( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceVulkanMemoryModelFeaturesKHR& operator=( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54095,53 +49704,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceVulkanMemoryModelFeaturesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR; + void* pNext = nullptr; + vk::Bool32 vulkanMemoryModel; + vk::Bool32 vulkanMemoryModelDeviceScope; + vk::Bool32 vulkanMemoryModelAvailabilityVisibilityChains; }; static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PhysicalDeviceYcbcrImageArraysFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( vk::Bool32 ycbcrImageArrays_ = 0 ) VULKAN_HPP_NOEXCEPT - : ycbcrImageArrays( ycbcrImageArrays_ ) - {} - - PhysicalDeviceYcbcrImageArraysFeaturesEXT( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT; - void* pNext = nullptr; - vk::Bool32 ycbcrImageArrays; - }; - static_assert( sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) == sizeof( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct PhysicalDeviceYcbcrImageArraysFeaturesEXT : public layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT + struct PhysicalDeviceYcbcrImageArraysFeaturesEXT { VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( vk::Bool32 ycbcrImageArrays_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT( ycbcrImageArrays_ ) + : ycbcrImageArrays( ycbcrImageArrays_ ) {} + vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT & operator=( vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PhysicalDeviceYcbcrImageArraysFeaturesEXT( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT( rhs ) - {} + { + *this = rhs; + } PhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54179,61 +49771,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PhysicalDeviceYcbcrImageArraysFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT; + void* pNext = nullptr; + vk::Bool32 ycbcrImageArrays; }; static_assert( sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) == sizeof( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineCacheCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( vk::PipelineCacheCreateFlags flags_ = vk::PipelineCacheCreateFlags(), - size_t initialDataSize_ = 0, - const void* pInitialData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , initialDataSize( initialDataSize_ ) - , pInitialData( pInitialData_ ) - {} - - PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineCacheCreateInfo; - const void* pNext = nullptr; - vk::PipelineCacheCreateFlags flags; - size_t initialDataSize; - const void* pInitialData; - }; - static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineCacheCreateInfo : public layout::PipelineCacheCreateInfo + struct PipelineCacheCreateInfo { VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( vk::PipelineCacheCreateFlags flags_ = vk::PipelineCacheCreateFlags(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCacheCreateInfo( flags_, initialDataSize_, pInitialData_ ) + : flags( flags_ ) + , initialDataSize( initialDataSize_ ) + , pInitialData( pInitialData_ ) {} + vk::PipelineCacheCreateInfo & operator=( vk::PipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCacheCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCacheCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineCacheCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54285,61 +49854,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineCacheCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineCacheCreateInfo; + const void* pNext = nullptr; + vk::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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineColorBlendAdvancedStateCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( vk::Bool32 srcPremultiplied_ = 0, - vk::Bool32 dstPremultiplied_ = 0, - vk::BlendOverlapEXT blendOverlap_ = vk::BlendOverlapEXT::eUncorrelated ) VULKAN_HPP_NOEXCEPT - : srcPremultiplied( srcPremultiplied_ ) - , dstPremultiplied( dstPremultiplied_ ) - , blendOverlap( blendOverlap_ ) - {} - - PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; - const void* pNext = nullptr; - vk::Bool32 srcPremultiplied; - vk::Bool32 dstPremultiplied; - vk::BlendOverlapEXT blendOverlap; - }; - static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineColorBlendAdvancedStateCreateInfoEXT : public layout::PipelineColorBlendAdvancedStateCreateInfoEXT + struct PipelineColorBlendAdvancedStateCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( vk::Bool32 srcPremultiplied_ = 0, vk::Bool32 dstPremultiplied_ = 0, vk::BlendOverlapEXT blendOverlap_ = vk::BlendOverlapEXT::eUncorrelated ) VULKAN_HPP_NOEXCEPT - : layout::PipelineColorBlendAdvancedStateCreateInfoEXT( srcPremultiplied_, dstPremultiplied_, blendOverlap_ ) + : srcPremultiplied( srcPremultiplied_ ) + , dstPremultiplied( dstPremultiplied_ ) + , blendOverlap( blendOverlap_ ) {} + vk::PipelineColorBlendAdvancedStateCreateInfoEXT & operator=( vk::PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineColorBlendAdvancedStateCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineColorBlendAdvancedStateCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineColorBlendAdvancedStateCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54391,53 +49939,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineColorBlendAdvancedStateCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; + const void* pNext = nullptr; + vk::Bool32 srcPremultiplied; + vk::Bool32 dstPremultiplied; + vk::BlendOverlapEXT blendOverlap; }; static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineCompilerControlCreateInfoAMD - { - protected: - VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ = vk::PipelineCompilerControlFlagsAMD() ) VULKAN_HPP_NOEXCEPT - : compilerControlFlags( compilerControlFlags_ ) - {} - - PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineCompilerControlCreateInfoAMD& operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineCompilerControlCreateInfoAMD; - const void* pNext = nullptr; - vk::PipelineCompilerControlFlagsAMD compilerControlFlags; - }; - static_assert( sizeof( PipelineCompilerControlCreateInfoAMD ) == sizeof( VkPipelineCompilerControlCreateInfoAMD ), "layout struct and wrapper have different size!" ); - } - - struct PipelineCompilerControlCreateInfoAMD : public layout::PipelineCompilerControlCreateInfoAMD + struct PipelineCompilerControlCreateInfoAMD { VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( vk::PipelineCompilerControlFlagsAMD compilerControlFlags_ = vk::PipelineCompilerControlFlagsAMD() ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCompilerControlCreateInfoAMD( compilerControlFlags_ ) + : compilerControlFlags( compilerControlFlags_ ) {} + vk::PipelineCompilerControlCreateInfoAMD & operator=( vk::PipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCompilerControlCreateInfoAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCompilerControlCreateInfoAMD( rhs ) - {} + { + *this = rhs; + } PipelineCompilerControlCreateInfoAMD& operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineCompilerControlCreateInfoAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54475,69 +50006,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineCompilerControlCreateInfoAMD::sType; + public: + const vk::StructureType sType = StructureType::ePipelineCompilerControlCreateInfoAMD; + const void* pNext = nullptr; + vk::PipelineCompilerControlFlagsAMD compilerControlFlags; }; static_assert( sizeof( PipelineCompilerControlCreateInfoAMD ) == sizeof( VkPipelineCompilerControlCreateInfoAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineCoverageModulationStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( vk::PipelineCoverageModulationStateCreateFlagsNV flags_ = vk::PipelineCoverageModulationStateCreateFlagsNV(), - vk::CoverageModulationModeNV coverageModulationMode_ = vk::CoverageModulationModeNV::eNone, - vk::Bool32 coverageModulationTableEnable_ = 0, - uint32_t coverageModulationTableCount_ = 0, - const float* pCoverageModulationTable_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , coverageModulationMode( coverageModulationMode_ ) - , coverageModulationTableEnable( coverageModulationTableEnable_ ) - , coverageModulationTableCount( coverageModulationTableCount_ ) - , pCoverageModulationTable( pCoverageModulationTable_ ) - {} - - PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV; - const void* pNext = nullptr; - vk::PipelineCoverageModulationStateCreateFlagsNV flags; - vk::CoverageModulationModeNV coverageModulationMode; - vk::Bool32 coverageModulationTableEnable; - uint32_t coverageModulationTableCount; - const float* pCoverageModulationTable; - }; - static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineCoverageModulationStateCreateInfoNV : public layout::PipelineCoverageModulationStateCreateInfoNV + struct PipelineCoverageModulationStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( vk::PipelineCoverageModulationStateCreateFlagsNV flags_ = vk::PipelineCoverageModulationStateCreateFlagsNV(), vk::CoverageModulationModeNV coverageModulationMode_ = vk::CoverageModulationModeNV::eNone, vk::Bool32 coverageModulationTableEnable_ = 0, uint32_t coverageModulationTableCount_ = 0, const float* pCoverageModulationTable_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCoverageModulationStateCreateInfoNV( flags_, coverageModulationMode_, coverageModulationTableEnable_, coverageModulationTableCount_, pCoverageModulationTable_ ) + : flags( flags_ ) + , coverageModulationMode( coverageModulationMode_ ) + , coverageModulationTableEnable( coverageModulationTableEnable_ ) + , coverageModulationTableCount( coverageModulationTableCount_ ) + , pCoverageModulationTable( pCoverageModulationTable_ ) {} + vk::PipelineCoverageModulationStateCreateInfoNV & operator=( vk::PipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCoverageModulationStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCoverageModulationStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineCoverageModulationStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54603,57 +50107,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineCoverageModulationStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV; + const void* pNext = nullptr; + vk::PipelineCoverageModulationStateCreateFlagsNV flags; + vk::CoverageModulationModeNV coverageModulationMode; + vk::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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineCoverageReductionStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( vk::PipelineCoverageReductionStateCreateFlagsNV flags_ = vk::PipelineCoverageReductionStateCreateFlagsNV(), - vk::CoverageReductionModeNV coverageReductionMode_ = vk::CoverageReductionModeNV::eMerge ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , coverageReductionMode( coverageReductionMode_ ) - {} - - PipelineCoverageReductionStateCreateInfoNV( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineCoverageReductionStateCreateInfoNV& operator=( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineCoverageReductionStateCreateInfoNV; - const void* pNext = nullptr; - vk::PipelineCoverageReductionStateCreateFlagsNV flags; - vk::CoverageReductionModeNV coverageReductionMode; - }; - static_assert( sizeof( PipelineCoverageReductionStateCreateInfoNV ) == sizeof( VkPipelineCoverageReductionStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineCoverageReductionStateCreateInfoNV : public layout::PipelineCoverageReductionStateCreateInfoNV + struct PipelineCoverageReductionStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( vk::PipelineCoverageReductionStateCreateFlagsNV flags_ = vk::PipelineCoverageReductionStateCreateFlagsNV(), vk::CoverageReductionModeNV coverageReductionMode_ = vk::CoverageReductionModeNV::eMerge ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCoverageReductionStateCreateInfoNV( flags_, coverageReductionMode_ ) + : flags( flags_ ) + , coverageReductionMode( coverageReductionMode_ ) {} + vk::PipelineCoverageReductionStateCreateInfoNV & operator=( vk::PipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCoverageReductionStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineCoverageReductionStateCreateInfoNV( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCoverageReductionStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineCoverageReductionStateCreateInfoNV& operator=( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineCoverageReductionStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54698,61 +50185,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineCoverageReductionStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineCoverageReductionStateCreateInfoNV; + const void* pNext = nullptr; + vk::PipelineCoverageReductionStateCreateFlagsNV flags; + vk::CoverageReductionModeNV coverageReductionMode; }; static_assert( sizeof( PipelineCoverageReductionStateCreateInfoNV ) == sizeof( VkPipelineCoverageReductionStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineCoverageToColorStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( vk::PipelineCoverageToColorStateCreateFlagsNV flags_ = vk::PipelineCoverageToColorStateCreateFlagsNV(), - vk::Bool32 coverageToColorEnable_ = 0, - uint32_t coverageToColorLocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , coverageToColorEnable( coverageToColorEnable_ ) - , coverageToColorLocation( coverageToColorLocation_ ) - {} - - PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV; - const void* pNext = nullptr; - vk::PipelineCoverageToColorStateCreateFlagsNV flags; - vk::Bool32 coverageToColorEnable; - uint32_t coverageToColorLocation; - }; - static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineCoverageToColorStateCreateInfoNV : public layout::PipelineCoverageToColorStateCreateInfoNV + struct PipelineCoverageToColorStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( vk::PipelineCoverageToColorStateCreateFlagsNV flags_ = vk::PipelineCoverageToColorStateCreateFlagsNV(), vk::Bool32 coverageToColorEnable_ = 0, uint32_t coverageToColorLocation_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCoverageToColorStateCreateInfoNV( flags_, coverageToColorEnable_, coverageToColorLocation_ ) + : flags( flags_ ) + , coverageToColorEnable( coverageToColorEnable_ ) + , coverageToColorLocation( coverageToColorLocation_ ) {} + vk::PipelineCoverageToColorStateCreateInfoNV & operator=( vk::PipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCoverageToColorStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCoverageToColorStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineCoverageToColorStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54804,25 +50269,32 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineCoverageToColorStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV; + const void* pNext = nullptr; + vk::PipelineCoverageToColorStateCreateFlagsNV flags; + vk::Bool32 coverageToColorEnable; + uint32_t coverageToColorLocation; }; static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct PipelineCreationFeedbackEXT { - PipelineCreationFeedbackEXT() VULKAN_HPP_NOEXCEPT + PipelineCreationFeedbackEXT( vk::PipelineCreationFeedbackFlagsEXT flags_ = vk::PipelineCreationFeedbackFlagsEXT(), + uint64_t duration_ = 0 ) VULKAN_HPP_NOEXCEPT + : flags( flags_ ) + , duration( duration_ ) {} PipelineCreationFeedbackEXT( VkPipelineCreationFeedbackEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PipelineCreationFeedbackEXT& operator=( VkPipelineCreationFeedbackEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -54854,55 +50326,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PipelineCreationFeedbackEXT ) == sizeof( VkPipelineCreationFeedbackEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineCreationFeedbackCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfoEXT( vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = nullptr, - uint32_t pipelineStageCreationFeedbackCount_ = 0, - vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pPipelineCreationFeedback( pPipelineCreationFeedback_ ) - , pipelineStageCreationFeedbackCount( pipelineStageCreationFeedbackCount_ ) - , pPipelineStageCreationFeedbacks( pPipelineStageCreationFeedbacks_ ) - {} - - PipelineCreationFeedbackCreateInfoEXT( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineCreationFeedbackCreateInfoEXT& operator=( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfoEXT; - const void* pNext = nullptr; - vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback; - uint32_t pipelineStageCreationFeedbackCount; - vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks; - }; - static_assert( sizeof( PipelineCreationFeedbackCreateInfoEXT ) == sizeof( VkPipelineCreationFeedbackCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineCreationFeedbackCreateInfoEXT : public layout::PipelineCreationFeedbackCreateInfoEXT + struct PipelineCreationFeedbackCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfoEXT( vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback_ = nullptr, uint32_t pipelineStageCreationFeedbackCount_ = 0, vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCreationFeedbackCreateInfoEXT( pPipelineCreationFeedback_, pipelineStageCreationFeedbackCount_, pPipelineStageCreationFeedbacks_ ) + : pPipelineCreationFeedback( pPipelineCreationFeedback_ ) + , pipelineStageCreationFeedbackCount( pipelineStageCreationFeedbackCount_ ) + , pPipelineStageCreationFeedbacks( pPipelineStageCreationFeedbacks_ ) {} + vk::PipelineCreationFeedbackCreateInfoEXT & operator=( vk::PipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineCreationFeedbackCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineCreationFeedbackCreateInfoEXT( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineCreationFeedbackCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineCreationFeedbackCreateInfoEXT& operator=( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineCreationFeedbackCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -54954,65 +50401,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineCreationFeedbackCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfoEXT; + const void* pNext = nullptr; + vk::PipelineCreationFeedbackEXT* pPipelineCreationFeedback; + uint32_t pipelineStageCreationFeedbackCount; + vk::PipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks; }; static_assert( sizeof( PipelineCreationFeedbackCreateInfoEXT ) == sizeof( VkPipelineCreationFeedbackCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineDiscardRectangleStateCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( vk::PipelineDiscardRectangleStateCreateFlagsEXT flags_ = vk::PipelineDiscardRectangleStateCreateFlagsEXT(), - vk::DiscardRectangleModeEXT discardRectangleMode_ = vk::DiscardRectangleModeEXT::eInclusive, - uint32_t discardRectangleCount_ = 0, - const vk::Rect2D* pDiscardRectangles_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , discardRectangleMode( discardRectangleMode_ ) - , discardRectangleCount( discardRectangleCount_ ) - , pDiscardRectangles( pDiscardRectangles_ ) - {} - - PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; - const void* pNext = nullptr; - vk::PipelineDiscardRectangleStateCreateFlagsEXT flags; - vk::DiscardRectangleModeEXT discardRectangleMode; - uint32_t discardRectangleCount; - const vk::Rect2D* pDiscardRectangles; - }; - static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineDiscardRectangleStateCreateInfoEXT : public layout::PipelineDiscardRectangleStateCreateInfoEXT + struct PipelineDiscardRectangleStateCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( vk::PipelineDiscardRectangleStateCreateFlagsEXT flags_ = vk::PipelineDiscardRectangleStateCreateFlagsEXT(), vk::DiscardRectangleModeEXT discardRectangleMode_ = vk::DiscardRectangleModeEXT::eInclusive, uint32_t discardRectangleCount_ = 0, const vk::Rect2D* pDiscardRectangles_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineDiscardRectangleStateCreateInfoEXT( flags_, discardRectangleMode_, discardRectangleCount_, pDiscardRectangles_ ) + : flags( flags_ ) + , discardRectangleMode( discardRectangleMode_ ) + , discardRectangleCount( discardRectangleCount_ ) + , pDiscardRectangles( pDiscardRectangles_ ) {} + vk::PipelineDiscardRectangleStateCreateInfoEXT & operator=( vk::PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineDiscardRectangleStateCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineDiscardRectangleStateCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineDiscardRectangleStateCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55071,57 +50495,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineDiscardRectangleStateCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; + const void* pNext = nullptr; + vk::PipelineDiscardRectangleStateCreateFlagsEXT flags; + vk::DiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + const vk::Rect2D* pDiscardRectangles; }; static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineExecutableInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline(), - uint32_t executableIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : pipeline( pipeline_ ) - , executableIndex( executableIndex_ ) - {} - - PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineExecutableInfoKHR& operator=( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineExecutableInfoKHR; - const void* pNext = nullptr; - vk::Pipeline pipeline; - uint32_t executableIndex; - }; - static_assert( sizeof( PipelineExecutableInfoKHR ) == sizeof( VkPipelineExecutableInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct PipelineExecutableInfoKHR : public layout::PipelineExecutableInfoKHR + struct PipelineExecutableInfoKHR { VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline(), uint32_t executableIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutableInfoKHR( pipeline_, executableIndex_ ) + : pipeline( pipeline_ ) + , executableIndex( executableIndex_ ) {} + vk::PipelineExecutableInfoKHR & operator=( vk::PipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineExecutableInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutableInfoKHR( rhs ) - {} + { + *this = rhs; + } PipelineExecutableInfoKHR& operator=( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineExecutableInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55166,72 +50572,46 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineExecutableInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::ePipelineExecutableInfoKHR; + const void* pNext = nullptr; + vk::Pipeline pipeline; + uint32_t executableIndex; }; static_assert( sizeof( PipelineExecutableInfoKHR ) == sizeof( VkPipelineExecutableInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineExecutableInternalRepresentationKHR - { - protected: - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInternalRepresentationKHR( std::array const& name_ = { { 0 } }, - std::array const& description_ = { { 0 } }, - vk::Bool32 isText_ = 0, - size_t dataSize_ = 0, - void* pData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : name{} - , description{} - , isText( isText_ ) - , dataSize( dataSize_ ) - , pData( pData_ ) - { - vk::ConstExpressionArrayCopy::copy( name, name_ ); - vk::ConstExpressionArrayCopy::copy( description, description_ ); - } - - PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineExecutableInternalRepresentationKHR& operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineExecutableInternalRepresentationKHR; - void* pNext = nullptr; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - vk::Bool32 isText; - size_t dataSize; - void* pData; - }; - static_assert( sizeof( PipelineExecutableInternalRepresentationKHR ) == sizeof( VkPipelineExecutableInternalRepresentationKHR ), "layout struct and wrapper have different size!" ); - } - - struct PipelineExecutableInternalRepresentationKHR : public layout::PipelineExecutableInternalRepresentationKHR + struct PipelineExecutableInternalRepresentationKHR { VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInternalRepresentationKHR( std::array const& name_ = { { 0 } }, std::array const& description_ = { { 0 } }, vk::Bool32 isText_ = 0, size_t dataSize_ = 0, void* pData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutableInternalRepresentationKHR( name_, description_, isText_, dataSize_, pData_ ) - {} + : name{} + , description{} + , isText( isText_ ) + , dataSize( dataSize_ ) + , pData( pData_ ) + { + vk::ConstExpressionArrayCopy::copy( name, name_ ); + vk::ConstExpressionArrayCopy::copy( description, description_ ); + } + + vk::PipelineExecutableInternalRepresentationKHR & operator=( vk::PipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineExecutableInternalRepresentationKHR ) - sizeof( vk::StructureType ) ); + return *this; + } PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutableInternalRepresentationKHR( rhs ) - {} + { + *this = rhs; + } PipelineExecutableInternalRepresentationKHR& operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineExecutableInternalRepresentationKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55297,55 +50677,47 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineExecutableInternalRepresentationKHR::sType; + public: + const vk::StructureType sType = StructureType::ePipelineExecutableInternalRepresentationKHR; + void* pNext = nullptr; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + vk::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::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PipelineExecutablePropertiesKHR { - struct PipelineExecutablePropertiesKHR + PipelineExecutablePropertiesKHR( vk::ShaderStageFlags stages_ = vk::ShaderStageFlags(), + std::array const& name_ = { { 0 } }, + std::array const& description_ = { { 0 } }, + uint32_t subgroupSize_ = 0 ) VULKAN_HPP_NOEXCEPT + : stages( stages_ ) + , name{} + , description{} + , subgroupSize( subgroupSize_ ) { - protected: - PipelineExecutablePropertiesKHR() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( name, name_ ); + vk::ConstExpressionArrayCopy::copy( description, description_ ); + } - PipelineExecutablePropertiesKHR( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineExecutablePropertiesKHR& operator=( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineExecutablePropertiesKHR; - void* pNext = nullptr; - vk::ShaderStageFlags stages; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - uint32_t subgroupSize; - }; - static_assert( sizeof( PipelineExecutablePropertiesKHR ) == sizeof( VkPipelineExecutablePropertiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct PipelineExecutablePropertiesKHR : public layout::PipelineExecutablePropertiesKHR - { - PipelineExecutablePropertiesKHR() VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutablePropertiesKHR() - {} + vk::PipelineExecutablePropertiesKHR & operator=( vk::PipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineExecutablePropertiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } PipelineExecutablePropertiesKHR( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutablePropertiesKHR( rhs ) - {} + { + *this = rhs; + } PipelineExecutablePropertiesKHR& operator=( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineExecutablePropertiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55374,8 +50746,13 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineExecutablePropertiesKHR::sType; + public: + const vk::StructureType sType = StructureType::ePipelineExecutablePropertiesKHR; + void* pNext = nullptr; + vk::ShaderStageFlags stages; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + uint32_t subgroupSize; }; static_assert( sizeof( PipelineExecutablePropertiesKHR ) == sizeof( VkPipelineExecutablePropertiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -55405,49 +50782,35 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ }; - namespace layout + struct PipelineExecutableStatisticKHR { - struct PipelineExecutableStatisticKHR + PipelineExecutableStatisticKHR( std::array const& name_ = { { 0 } }, + std::array const& description_ = { { 0 } }, + vk::PipelineExecutableStatisticFormatKHR format_ = vk::PipelineExecutableStatisticFormatKHR::eBool32, + vk::PipelineExecutableStatisticValueKHR value_ = vk::PipelineExecutableStatisticValueKHR() ) VULKAN_HPP_NOEXCEPT + : name{} + , description{} + , format( format_ ) + , value( value_ ) { - protected: - PipelineExecutableStatisticKHR() VULKAN_HPP_NOEXCEPT - {} + vk::ConstExpressionArrayCopy::copy( name, name_ ); + vk::ConstExpressionArrayCopy::copy( description, description_ ); + } - PipelineExecutableStatisticKHR( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineExecutableStatisticKHR& operator=( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineExecutableStatisticKHR; - void* pNext = nullptr; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - vk::PipelineExecutableStatisticFormatKHR format; - vk::PipelineExecutableStatisticValueKHR value; - }; - static_assert( sizeof( PipelineExecutableStatisticKHR ) == sizeof( VkPipelineExecutableStatisticKHR ), "layout struct and wrapper have different size!" ); - } - - struct PipelineExecutableStatisticKHR : public layout::PipelineExecutableStatisticKHR - { - PipelineExecutableStatisticKHR() VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutableStatisticKHR() - {} + vk::PipelineExecutableStatisticKHR & operator=( vk::PipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineExecutableStatisticKHR ) - sizeof( vk::StructureType ) ); + return *this; + } PipelineExecutableStatisticKHR( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineExecutableStatisticKHR( rhs ) - {} + { + *this = rhs; + } PipelineExecutableStatisticKHR& operator=( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineExecutableStatisticKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55461,53 +50824,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } - private: - using layout::PipelineExecutableStatisticKHR::sType; + public: + const vk::StructureType sType = StructureType::ePipelineExecutableStatisticKHR; + void* pNext = nullptr; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + vk::PipelineExecutableStatisticFormatKHR format; + vk::PipelineExecutableStatisticValueKHR value; }; static_assert( sizeof( PipelineExecutableStatisticKHR ) == sizeof( VkPipelineExecutableStatisticKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR PipelineInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline() ) VULKAN_HPP_NOEXCEPT - : pipeline( pipeline_ ) - {} - - PipelineInfoKHR( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineInfoKHR& operator=( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineInfoKHR; - const void* pNext = nullptr; - vk::Pipeline pipeline; - }; - static_assert( sizeof( PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct PipelineInfoKHR : public layout::PipelineInfoKHR + struct PipelineInfoKHR { VULKAN_HPP_CONSTEXPR PipelineInfoKHR( vk::Pipeline pipeline_ = vk::Pipeline() ) VULKAN_HPP_NOEXCEPT - : layout::PipelineInfoKHR( pipeline_ ) + : pipeline( pipeline_ ) {} + vk::PipelineInfoKHR & operator=( vk::PipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineInfoKHR( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineInfoKHR( rhs ) - {} + { + *this = rhs; + } PipelineInfoKHR& operator=( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55545,8 +50892,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::ePipelineInfoKHR; + const void* pNext = nullptr; + vk::Pipeline pipeline; }; static_assert( sizeof( PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -55563,12 +50912,12 @@ namespace VULKAN_HPP_NAMESPACE PushConstantRange( VkPushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PushConstantRange& operator=( VkPushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -55620,63 +50969,34 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineLayoutCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( vk::PipelineLayoutCreateFlags flags_ = vk::PipelineLayoutCreateFlags(), - uint32_t setLayoutCount_ = 0, - const vk::DescriptorSetLayout* pSetLayouts_ = nullptr, - uint32_t pushConstantRangeCount_ = 0, - const vk::PushConstantRange* pPushConstantRanges_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , setLayoutCount( setLayoutCount_ ) - , pSetLayouts( pSetLayouts_ ) - , pushConstantRangeCount( pushConstantRangeCount_ ) - , pPushConstantRanges( pPushConstantRanges_ ) - {} - - PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineLayoutCreateInfo; - const void* pNext = nullptr; - vk::PipelineLayoutCreateFlags flags; - uint32_t setLayoutCount; - const vk::DescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const vk::PushConstantRange* pPushConstantRanges; - }; - static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineLayoutCreateInfo : public layout::PipelineLayoutCreateInfo + struct PipelineLayoutCreateInfo { VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( vk::PipelineLayoutCreateFlags flags_ = vk::PipelineLayoutCreateFlags(), uint32_t setLayoutCount_ = 0, const vk::DescriptorSetLayout* pSetLayouts_ = nullptr, uint32_t pushConstantRangeCount_ = 0, const vk::PushConstantRange* pPushConstantRanges_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineLayoutCreateInfo( flags_, setLayoutCount_, pSetLayouts_, pushConstantRangeCount_, pPushConstantRanges_ ) + : flags( flags_ ) + , setLayoutCount( setLayoutCount_ ) + , pSetLayouts( pSetLayouts_ ) + , pushConstantRangeCount( pushConstantRangeCount_ ) + , pPushConstantRanges( pPushConstantRanges_ ) {} + vk::PipelineLayoutCreateInfo & operator=( vk::PipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineLayoutCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineLayoutCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineLayoutCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55742,61 +51062,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineLayoutCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineLayoutCreateInfo; + const void* pNext = nullptr; + vk::PipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const vk::DescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const vk::PushConstantRange* pPushConstantRanges; }; static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineRasterizationConservativeStateCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = vk::PipelineRasterizationConservativeStateCreateFlagsEXT(), - vk::ConservativeRasterizationModeEXT conservativeRasterizationMode_ = vk::ConservativeRasterizationModeEXT::eDisabled, - float extraPrimitiveOverestimationSize_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , conservativeRasterizationMode( conservativeRasterizationMode_ ) - , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ ) - {} - - PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT; - const void* pNext = nullptr; - vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags; - vk::ConservativeRasterizationModeEXT conservativeRasterizationMode; - float extraPrimitiveOverestimationSize; - }; - static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineRasterizationConservativeStateCreateInfoEXT : public layout::PipelineRasterizationConservativeStateCreateInfoEXT + struct PipelineRasterizationConservativeStateCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = vk::PipelineRasterizationConservativeStateCreateFlagsEXT(), vk::ConservativeRasterizationModeEXT conservativeRasterizationMode_ = vk::ConservativeRasterizationModeEXT::eDisabled, float extraPrimitiveOverestimationSize_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationConservativeStateCreateInfoEXT( flags_, conservativeRasterizationMode_, extraPrimitiveOverestimationSize_ ) + : flags( flags_ ) + , conservativeRasterizationMode( conservativeRasterizationMode_ ) + , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ ) {} + vk::PipelineRasterizationConservativeStateCreateInfoEXT & operator=( vk::PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationConservativeStateCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationConservativeStateCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineRasterizationConservativeStateCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55848,57 +51149,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineRasterizationConservativeStateCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT; + const void* pNext = nullptr; + vk::PipelineRasterizationConservativeStateCreateFlagsEXT flags; + vk::ConservativeRasterizationModeEXT conservativeRasterizationMode; + float extraPrimitiveOverestimationSize; }; static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineRasterizationDepthClipStateCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = vk::PipelineRasterizationDepthClipStateCreateFlagsEXT(), - vk::Bool32 depthClipEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , depthClipEnable( depthClipEnable_ ) - {} - - PipelineRasterizationDepthClipStateCreateInfoEXT( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineRasterizationDepthClipStateCreateInfoEXT& operator=( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT; - const void* pNext = nullptr; - vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags; - vk::Bool32 depthClipEnable; - }; - static_assert( sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationDepthClipStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineRasterizationDepthClipStateCreateInfoEXT : public layout::PipelineRasterizationDepthClipStateCreateInfoEXT + struct PipelineRasterizationDepthClipStateCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = vk::PipelineRasterizationDepthClipStateCreateFlagsEXT(), vk::Bool32 depthClipEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationDepthClipStateCreateInfoEXT( flags_, depthClipEnable_ ) + : flags( flags_ ) + , depthClipEnable( depthClipEnable_ ) {} + vk::PipelineRasterizationDepthClipStateCreateInfoEXT & operator=( vk::PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationDepthClipStateCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineRasterizationDepthClipStateCreateInfoEXT( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationDepthClipStateCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineRasterizationDepthClipStateCreateInfoEXT& operator=( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineRasterizationDepthClipStateCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -55943,65 +51225,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineRasterizationDepthClipStateCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT; + const void* pNext = nullptr; + vk::PipelineRasterizationDepthClipStateCreateFlagsEXT flags; + vk::Bool32 depthClipEnable; }; static_assert( sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationDepthClipStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineRasterizationLineStateCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT( vk::LineRasterizationModeEXT lineRasterizationMode_ = vk::LineRasterizationModeEXT::eDefault, - vk::Bool32 stippledLineEnable_ = 0, - uint32_t lineStippleFactor_ = 0, - uint16_t lineStipplePattern_ = 0 ) VULKAN_HPP_NOEXCEPT - : lineRasterizationMode( lineRasterizationMode_ ) - , stippledLineEnable( stippledLineEnable_ ) - , lineStippleFactor( lineStippleFactor_ ) - , lineStipplePattern( lineStipplePattern_ ) - {} - - PipelineRasterizationLineStateCreateInfoEXT( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineRasterizationLineStateCreateInfoEXT& operator=( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineRasterizationLineStateCreateInfoEXT; - const void* pNext = nullptr; - vk::LineRasterizationModeEXT lineRasterizationMode; - vk::Bool32 stippledLineEnable; - uint32_t lineStippleFactor; - uint16_t lineStipplePattern; - }; - static_assert( sizeof( PipelineRasterizationLineStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationLineStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineRasterizationLineStateCreateInfoEXT : public layout::PipelineRasterizationLineStateCreateInfoEXT + struct PipelineRasterizationLineStateCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfoEXT( vk::LineRasterizationModeEXT lineRasterizationMode_ = vk::LineRasterizationModeEXT::eDefault, vk::Bool32 stippledLineEnable_ = 0, uint32_t lineStippleFactor_ = 0, uint16_t lineStipplePattern_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationLineStateCreateInfoEXT( lineRasterizationMode_, stippledLineEnable_, lineStippleFactor_, lineStipplePattern_ ) + : lineRasterizationMode( lineRasterizationMode_ ) + , stippledLineEnable( stippledLineEnable_ ) + , lineStippleFactor( lineStippleFactor_ ) + , lineStipplePattern( lineStipplePattern_ ) {} + vk::PipelineRasterizationLineStateCreateInfoEXT & operator=( vk::PipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationLineStateCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineRasterizationLineStateCreateInfoEXT( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationLineStateCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineRasterizationLineStateCreateInfoEXT& operator=( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineRasterizationLineStateCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56060,53 +51318,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineRasterizationLineStateCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineRasterizationLineStateCreateInfoEXT; + const void* pNext = nullptr; + vk::LineRasterizationModeEXT lineRasterizationMode; + vk::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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineRasterizationStateRasterizationOrderAMD - { - protected: - VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( vk::RasterizationOrderAMD rasterizationOrder_ = vk::RasterizationOrderAMD::eStrict ) VULKAN_HPP_NOEXCEPT - : rasterizationOrder( rasterizationOrder_ ) - {} - - PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD; - const void* pNext = nullptr; - vk::RasterizationOrderAMD rasterizationOrder; - }; - static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "layout struct and wrapper have different size!" ); - } - - struct PipelineRasterizationStateRasterizationOrderAMD : public layout::PipelineRasterizationStateRasterizationOrderAMD + struct PipelineRasterizationStateRasterizationOrderAMD { VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( vk::RasterizationOrderAMD rasterizationOrder_ = vk::RasterizationOrderAMD::eStrict ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationStateRasterizationOrderAMD( rasterizationOrder_ ) + : rasterizationOrder( rasterizationOrder_ ) {} + vk::PipelineRasterizationStateRasterizationOrderAMD & operator=( vk::PipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationStateRasterizationOrderAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationStateRasterizationOrderAMD( rhs ) - {} + { + *this = rhs; + } PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineRasterizationStateRasterizationOrderAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56144,57 +51386,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineRasterizationStateRasterizationOrderAMD::sType; + public: + const vk::StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD; + const void* pNext = nullptr; + vk::RasterizationOrderAMD rasterizationOrder; }; static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineRasterizationStateStreamCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( vk::PipelineRasterizationStateStreamCreateFlagsEXT flags_ = vk::PipelineRasterizationStateStreamCreateFlagsEXT(), - uint32_t rasterizationStream_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , rasterizationStream( rasterizationStream_ ) - {} - - PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT; - const void* pNext = nullptr; - vk::PipelineRasterizationStateStreamCreateFlagsEXT flags; - uint32_t rasterizationStream; - }; - static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineRasterizationStateStreamCreateInfoEXT : public layout::PipelineRasterizationStateStreamCreateInfoEXT + struct PipelineRasterizationStateStreamCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( vk::PipelineRasterizationStateStreamCreateFlagsEXT flags_ = vk::PipelineRasterizationStateStreamCreateFlagsEXT(), uint32_t rasterizationStream_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationStateStreamCreateInfoEXT( flags_, rasterizationStream_ ) + : flags( flags_ ) + , rasterizationStream( rasterizationStream_ ) {} + vk::PipelineRasterizationStateStreamCreateInfoEXT & operator=( vk::PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRasterizationStateStreamCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRasterizationStateStreamCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineRasterizationStateStreamCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56239,53 +51460,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineRasterizationStateStreamCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT; + const void* pNext = nullptr; + vk::PipelineRasterizationStateStreamCreateFlagsEXT flags; + uint32_t rasterizationStream; }; static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineRepresentativeFragmentTestStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( vk::Bool32 representativeFragmentTestEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : representativeFragmentTestEnable( representativeFragmentTestEnable_ ) - {} - - PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV; - const void* pNext = nullptr; - vk::Bool32 representativeFragmentTestEnable; - }; - static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineRepresentativeFragmentTestStateCreateInfoNV : public layout::PipelineRepresentativeFragmentTestStateCreateInfoNV + struct PipelineRepresentativeFragmentTestStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( vk::Bool32 representativeFragmentTestEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRepresentativeFragmentTestStateCreateInfoNV( representativeFragmentTestEnable_ ) + : representativeFragmentTestEnable( representativeFragmentTestEnable_ ) {} + vk::PipelineRepresentativeFragmentTestStateCreateInfoNV & operator=( vk::PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineRepresentativeFragmentTestStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineRepresentativeFragmentTestStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineRepresentativeFragmentTestStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56323,57 +51526,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineRepresentativeFragmentTestStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV; + const void* pNext = nullptr; + vk::Bool32 representativeFragmentTestEnable; }; static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineSampleLocationsStateCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( vk::Bool32 sampleLocationsEnable_ = 0, - vk::SampleLocationsInfoEXT sampleLocationsInfo_ = vk::SampleLocationsInfoEXT() ) VULKAN_HPP_NOEXCEPT - : sampleLocationsEnable( sampleLocationsEnable_ ) - , sampleLocationsInfo( sampleLocationsInfo_ ) - {} - - PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT; - const void* pNext = nullptr; - vk::Bool32 sampleLocationsEnable; - vk::SampleLocationsInfoEXT sampleLocationsInfo; - }; - static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineSampleLocationsStateCreateInfoEXT : public layout::PipelineSampleLocationsStateCreateInfoEXT + struct PipelineSampleLocationsStateCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( vk::Bool32 sampleLocationsEnable_ = 0, vk::SampleLocationsInfoEXT sampleLocationsInfo_ = vk::SampleLocationsInfoEXT() ) VULKAN_HPP_NOEXCEPT - : layout::PipelineSampleLocationsStateCreateInfoEXT( sampleLocationsEnable_, sampleLocationsInfo_ ) + : sampleLocationsEnable( sampleLocationsEnable_ ) + , sampleLocationsInfo( sampleLocationsInfo_ ) {} + vk::PipelineSampleLocationsStateCreateInfoEXT & operator=( vk::PipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineSampleLocationsStateCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineSampleLocationsStateCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineSampleLocationsStateCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56418,52 +51600,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineSampleLocationsStateCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT; + const void* pNext = nullptr; + vk::Bool32 sampleLocationsEnable; + vk::SampleLocationsInfoEXT sampleLocationsInfo; }; static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT { - struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT - { - protected: - PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT() VULKAN_HPP_NOEXCEPT - {} - - PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& operator=( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; - void* pNext = nullptr; - uint32_t requiredSubgroupSize; - }; - static_assert( sizeof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) == sizeof( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT : public layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT - { - PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT() VULKAN_HPP_NOEXCEPT - : layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT() + PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( uint32_t requiredSubgroupSize_ = 0 ) VULKAN_HPP_NOEXCEPT + : requiredSubgroupSize( requiredSubgroupSize_ ) {} + vk::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT & operator=( vk::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& operator=( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56489,53 +51654,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; + void* pNext = nullptr; + uint32_t requiredSubgroupSize; }; static_assert( sizeof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) == sizeof( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineTessellationDomainOriginStateCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( vk::TessellationDomainOrigin domainOrigin_ = vk::TessellationDomainOrigin::eUpperLeft ) VULKAN_HPP_NOEXCEPT - : domainOrigin( domainOrigin_ ) - {} - - PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo; - const void* pNext = nullptr; - vk::TessellationDomainOrigin domainOrigin; - }; - static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct PipelineTessellationDomainOriginStateCreateInfo : public layout::PipelineTessellationDomainOriginStateCreateInfo + struct PipelineTessellationDomainOriginStateCreateInfo { VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( vk::TessellationDomainOrigin domainOrigin_ = vk::TessellationDomainOrigin::eUpperLeft ) VULKAN_HPP_NOEXCEPT - : layout::PipelineTessellationDomainOriginStateCreateInfo( domainOrigin_ ) + : domainOrigin( domainOrigin_ ) {} + vk::PipelineTessellationDomainOriginStateCreateInfo & operator=( vk::PipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineTessellationDomainOriginStateCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineTessellationDomainOriginStateCreateInfo( rhs ) - {} + { + *this = rhs; + } PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineTessellationDomainOriginStateCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56573,8 +51719,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineTessellationDomainOriginStateCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo; + const void* pNext = nullptr; + vk::TessellationDomainOrigin domainOrigin; }; static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -56589,12 +51737,12 @@ namespace VULKAN_HPP_NAMESPACE VertexInputBindingDivisorDescriptionEXT( VkVertexInputBindingDivisorDescriptionEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } VertexInputBindingDivisorDescriptionEXT& operator=( VkVertexInputBindingDivisorDescriptionEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -56638,51 +51786,28 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineVertexInputDivisorStateCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0, - const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr ) VULKAN_HPP_NOEXCEPT - : vertexBindingDivisorCount( vertexBindingDivisorCount_ ) - , pVertexBindingDivisors( pVertexBindingDivisors_ ) - {} - - PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT; - const void* pNext = nullptr; - uint32_t vertexBindingDivisorCount; - const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; - }; - static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct PipelineVertexInputDivisorStateCreateInfoEXT : public layout::PipelineVertexInputDivisorStateCreateInfoEXT + struct PipelineVertexInputDivisorStateCreateInfoEXT { VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfoEXT( uint32_t vertexBindingDivisorCount_ = 0, const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineVertexInputDivisorStateCreateInfoEXT( vertexBindingDivisorCount_, pVertexBindingDivisors_ ) + : vertexBindingDivisorCount( vertexBindingDivisorCount_ ) + , pVertexBindingDivisors( pVertexBindingDivisors_ ) {} + vk::PipelineVertexInputDivisorStateCreateInfoEXT & operator=( vk::PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineVertexInputDivisorStateCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineVertexInputDivisorStateCreateInfoEXT( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineVertexInputDivisorStateCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineVertexInputDivisorStateCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56727,61 +51852,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineVertexInputDivisorStateCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT; + const void* pNext = nullptr; + uint32_t vertexBindingDivisorCount; + const vk::VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; }; static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineViewportCoarseSampleOrderStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( vk::CoarseSampleOrderTypeNV sampleOrderType_ = vk::CoarseSampleOrderTypeNV::eDefault, - uint32_t customSampleOrderCount_ = 0, - const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr ) VULKAN_HPP_NOEXCEPT - : sampleOrderType( sampleOrderType_ ) - , customSampleOrderCount( customSampleOrderCount_ ) - , pCustomSampleOrders( pCustomSampleOrders_ ) - {} - - PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV; - const void* pNext = nullptr; - vk::CoarseSampleOrderTypeNV sampleOrderType; - uint32_t customSampleOrderCount; - const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders; - }; - static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineViewportCoarseSampleOrderStateCreateInfoNV : public layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV + struct PipelineViewportCoarseSampleOrderStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( vk::CoarseSampleOrderTypeNV sampleOrderType_ = vk::CoarseSampleOrderTypeNV::eDefault, uint32_t customSampleOrderCount_ = 0, const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV( sampleOrderType_, customSampleOrderCount_, pCustomSampleOrders_ ) + : sampleOrderType( sampleOrderType_ ) + , customSampleOrderCount( customSampleOrderCount_ ) + , pCustomSampleOrders( pCustomSampleOrders_ ) {} + vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV & operator=( vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56833,57 +51936,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineViewportCoarseSampleOrderStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV; + const void* pNext = nullptr; + vk::CoarseSampleOrderTypeNV sampleOrderType; + uint32_t customSampleOrderCount; + const vk::CoarseSampleOrderCustomNV* pCustomSampleOrders; }; static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineViewportExclusiveScissorStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0, - const vk::Rect2D* pExclusiveScissors_ = nullptr ) VULKAN_HPP_NOEXCEPT - : exclusiveScissorCount( exclusiveScissorCount_ ) - , pExclusiveScissors( pExclusiveScissors_ ) - {} - - PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV; - const void* pNext = nullptr; - uint32_t exclusiveScissorCount; - const vk::Rect2D* pExclusiveScissors; - }; - static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineViewportExclusiveScissorStateCreateInfoNV : public layout::PipelineViewportExclusiveScissorStateCreateInfoNV + struct PipelineViewportExclusiveScissorStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = 0, const vk::Rect2D* pExclusiveScissors_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportExclusiveScissorStateCreateInfoNV( exclusiveScissorCount_, pExclusiveScissors_ ) + : exclusiveScissorCount( exclusiveScissorCount_ ) + , pExclusiveScissors( pExclusiveScissors_ ) {} + vk::PipelineViewportExclusiveScissorStateCreateInfoNV & operator=( vk::PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportExclusiveScissorStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportExclusiveScissorStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineViewportExclusiveScissorStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -56928,8 +52012,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineViewportExclusiveScissorStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV; + const void* pNext = nullptr; + uint32_t exclusiveScissorCount; + const vk::Rect2D* pExclusiveScissors; }; static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -56944,12 +52031,12 @@ namespace VULKAN_HPP_NAMESPACE ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ShadingRatePaletteNV& operator=( VkShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -56993,55 +52080,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ShadingRatePaletteNV ) == sizeof( VkShadingRatePaletteNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineViewportShadingRateImageStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( vk::Bool32 shadingRateImageEnable_ = 0, - uint32_t viewportCount_ = 0, - const vk::ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr ) VULKAN_HPP_NOEXCEPT - : shadingRateImageEnable( shadingRateImageEnable_ ) - , viewportCount( viewportCount_ ) - , pShadingRatePalettes( pShadingRatePalettes_ ) - {} - - PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV; - const void* pNext = nullptr; - vk::Bool32 shadingRateImageEnable; - uint32_t viewportCount; - const vk::ShadingRatePaletteNV* pShadingRatePalettes; - }; - static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineViewportShadingRateImageStateCreateInfoNV : public layout::PipelineViewportShadingRateImageStateCreateInfoNV + struct PipelineViewportShadingRateImageStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( vk::Bool32 shadingRateImageEnable_ = 0, uint32_t viewportCount_ = 0, const vk::ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportShadingRateImageStateCreateInfoNV( shadingRateImageEnable_, viewportCount_, pShadingRatePalettes_ ) + : shadingRateImageEnable( shadingRateImageEnable_ ) + , viewportCount( viewportCount_ ) + , pShadingRatePalettes( pShadingRatePalettes_ ) {} + vk::PipelineViewportShadingRateImageStateCreateInfoNV & operator=( vk::PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportShadingRateImageStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportShadingRateImageStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineViewportShadingRateImageStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -57093,8 +52155,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineViewportShadingRateImageStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV; + const void* pNext = nullptr; + vk::Bool32 shadingRateImageEnable; + uint32_t viewportCount; + const vk::ShadingRatePaletteNV* pShadingRatePalettes; }; static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -57113,12 +52179,12 @@ namespace VULKAN_HPP_NAMESPACE ViewportSwizzleNV( VkViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -57178,55 +52244,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineViewportSwizzleStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( vk::PipelineViewportSwizzleStateCreateFlagsNV flags_ = vk::PipelineViewportSwizzleStateCreateFlagsNV(), - uint32_t viewportCount_ = 0, - const vk::ViewportSwizzleNV* pViewportSwizzles_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , viewportCount( viewportCount_ ) - , pViewportSwizzles( pViewportSwizzles_ ) - {} - - PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV; - const void* pNext = nullptr; - vk::PipelineViewportSwizzleStateCreateFlagsNV flags; - uint32_t viewportCount; - const vk::ViewportSwizzleNV* pViewportSwizzles; - }; - static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineViewportSwizzleStateCreateInfoNV : public layout::PipelineViewportSwizzleStateCreateInfoNV + struct PipelineViewportSwizzleStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( vk::PipelineViewportSwizzleStateCreateFlagsNV flags_ = vk::PipelineViewportSwizzleStateCreateFlagsNV(), uint32_t viewportCount_ = 0, const vk::ViewportSwizzleNV* pViewportSwizzles_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportSwizzleStateCreateInfoNV( flags_, viewportCount_, pViewportSwizzles_ ) + : flags( flags_ ) + , viewportCount( viewportCount_ ) + , pViewportSwizzles( pViewportSwizzles_ ) {} + vk::PipelineViewportSwizzleStateCreateInfoNV & operator=( vk::PipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportSwizzleStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportSwizzleStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineViewportSwizzleStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -57278,8 +52319,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineViewportSwizzleStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV; + const void* pNext = nullptr; + vk::PipelineViewportSwizzleStateCreateFlagsNV flags; + uint32_t viewportCount; + const vk::ViewportSwizzleNV* pViewportSwizzles; }; static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -57294,12 +52339,12 @@ namespace VULKAN_HPP_NAMESPACE ViewportWScalingNV( VkViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -57343,55 +52388,30 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PipelineViewportWScalingStateCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( vk::Bool32 viewportWScalingEnable_ = 0, - uint32_t viewportCount_ = 0, - const vk::ViewportWScalingNV* pViewportWScalings_ = nullptr ) VULKAN_HPP_NOEXCEPT - : viewportWScalingEnable( viewportWScalingEnable_ ) - , viewportCount( viewportCount_ ) - , pViewportWScalings( pViewportWScalings_ ) - {} - - PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV; - const void* pNext = nullptr; - vk::Bool32 viewportWScalingEnable; - uint32_t viewportCount; - const vk::ViewportWScalingNV* pViewportWScalings; - }; - static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct PipelineViewportWScalingStateCreateInfoNV : public layout::PipelineViewportWScalingStateCreateInfoNV + struct PipelineViewportWScalingStateCreateInfoNV { VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( vk::Bool32 viewportWScalingEnable_ = 0, uint32_t viewportCount_ = 0, const vk::ViewportWScalingNV* pViewportWScalings_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportWScalingStateCreateInfoNV( viewportWScalingEnable_, viewportCount_, pViewportWScalings_ ) + : viewportWScalingEnable( viewportWScalingEnable_ ) + , viewportCount( viewportCount_ ) + , pViewportWScalings( pViewportWScalings_ ) {} + vk::PipelineViewportWScalingStateCreateInfoNV & operator=( vk::PipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PipelineViewportWScalingStateCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PipelineViewportWScalingStateCreateInfoNV( rhs ) - {} + { + *this = rhs; + } PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PipelineViewportWScalingStateCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -57443,55 +52463,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PipelineViewportWScalingStateCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV; + const void* pNext = nullptr; + vk::Bool32 viewportWScalingEnable; + uint32_t viewportCount; + const vk::ViewportWScalingNV* pViewportWScalings; }; static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_GGP - namespace layout - { - struct PresentFrameTokenGGP - { - protected: - VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( GgpFrameToken frameToken_ = 0 ) VULKAN_HPP_NOEXCEPT - : frameToken( frameToken_ ) - {} - - PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PresentFrameTokenGGP& operator=( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePresentFrameTokenGGP; - const void* pNext = nullptr; - GgpFrameToken frameToken; - }; - static_assert( sizeof( PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "layout struct and wrapper have different size!" ); - } - - struct PresentFrameTokenGGP : public layout::PresentFrameTokenGGP + struct PresentFrameTokenGGP { VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( GgpFrameToken frameToken_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::PresentFrameTokenGGP( frameToken_ ) + : frameToken( frameToken_ ) {} + vk::PresentFrameTokenGGP & operator=( vk::PresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PresentFrameTokenGGP ) - sizeof( vk::StructureType ) ); + return *this; + } + PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PresentFrameTokenGGP( rhs ) - {} + { + *this = rhs; + } PresentFrameTokenGGP& operator=( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PresentFrameTokenGGP::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -57529,57 +52532,16 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PresentFrameTokenGGP::sType; + public: + const vk::StructureType sType = StructureType::ePresentFrameTokenGGP; + const void* pNext = nullptr; + GgpFrameToken frameToken; }; static_assert( sizeof( PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_GGP*/ - namespace layout - { - struct PresentInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, - const vk::Semaphore* pWaitSemaphores_ = nullptr, - uint32_t swapchainCount_ = 0, - const vk::SwapchainKHR* pSwapchains_ = nullptr, - const uint32_t* pImageIndices_ = nullptr, - vk::Result* pResults_ = nullptr ) VULKAN_HPP_NOEXCEPT - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphores( pWaitSemaphores_ ) - , swapchainCount( swapchainCount_ ) - , pSwapchains( pSwapchains_ ) - , pImageIndices( pImageIndices_ ) - , pResults( pResults_ ) - {} - - PresentInfoKHR( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePresentInfoKHR; - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const vk::Semaphore* pWaitSemaphores; - uint32_t swapchainCount; - const vk::SwapchainKHR* pSwapchains; - const uint32_t* pImageIndices; - vk::Result* pResults; - }; - static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct PresentInfoKHR : public layout::PresentInfoKHR + struct PresentInfoKHR { VULKAN_HPP_CONSTEXPR PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, const vk::Semaphore* pWaitSemaphores_ = nullptr, @@ -57587,16 +52549,28 @@ namespace VULKAN_HPP_NAMESPACE const vk::SwapchainKHR* pSwapchains_ = nullptr, const uint32_t* pImageIndices_ = nullptr, vk::Result* pResults_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PresentInfoKHR( waitSemaphoreCount_, pWaitSemaphores_, swapchainCount_, pSwapchains_, pImageIndices_, pResults_ ) + : waitSemaphoreCount( waitSemaphoreCount_ ) + , pWaitSemaphores( pWaitSemaphores_ ) + , swapchainCount( swapchainCount_ ) + , pSwapchains( pSwapchains_ ) + , pImageIndices( pImageIndices_ ) + , pResults( pResults_ ) {} + vk::PresentInfoKHR & operator=( vk::PresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PresentInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PresentInfoKHR( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PresentInfoKHR( rhs ) - {} + { + *this = rhs; + } PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PresentInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -57669,8 +52643,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PresentInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::ePresentInfoKHR; + const void* pNext = nullptr; + uint32_t waitSemaphoreCount; + const vk::Semaphore* pWaitSemaphores; + uint32_t swapchainCount; + const vk::SwapchainKHR* pSwapchains; + const uint32_t* pImageIndices; + vk::Result* pResults; }; static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -57694,12 +52675,12 @@ namespace VULKAN_HPP_NAMESPACE RectLayerKHR( VkRectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } RectLayerKHR& operator=( VkRectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -57761,12 +52742,12 @@ namespace VULKAN_HPP_NAMESPACE PresentRegionKHR( VkPresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -57810,51 +52791,28 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PresentRegionsKHR - { - protected: - VULKAN_HPP_CONSTEXPR PresentRegionsKHR( uint32_t swapchainCount_ = 0, - const vk::PresentRegionKHR* pRegions_ = nullptr ) VULKAN_HPP_NOEXCEPT - : swapchainCount( swapchainCount_ ) - , pRegions( pRegions_ ) - {} - - PresentRegionsKHR( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePresentRegionsKHR; - const void* pNext = nullptr; - uint32_t swapchainCount; - const vk::PresentRegionKHR* pRegions; - }; - static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "layout struct and wrapper have different size!" ); - } - - struct PresentRegionsKHR : public layout::PresentRegionsKHR + struct PresentRegionsKHR { VULKAN_HPP_CONSTEXPR PresentRegionsKHR( uint32_t swapchainCount_ = 0, const vk::PresentRegionKHR* pRegions_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PresentRegionsKHR( swapchainCount_, pRegions_ ) + : swapchainCount( swapchainCount_ ) + , pRegions( pRegions_ ) {} + vk::PresentRegionsKHR & operator=( vk::PresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PresentRegionsKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + PresentRegionsKHR( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PresentRegionsKHR( rhs ) - {} + { + *this = rhs; + } PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PresentRegionsKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -57899,8 +52857,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PresentRegionsKHR::sType; + public: + const vk::StructureType sType = StructureType::ePresentRegionsKHR; + const void* pNext = nullptr; + uint32_t swapchainCount; + const vk::PresentRegionKHR* pRegions; }; static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -57915,12 +52876,12 @@ namespace VULKAN_HPP_NAMESPACE PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -57964,51 +52925,28 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct PresentTimesInfoGOOGLE - { - protected: - VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0, - const vk::PresentTimeGOOGLE* pTimes_ = nullptr ) VULKAN_HPP_NOEXCEPT - : swapchainCount( swapchainCount_ ) - , pTimes( pTimes_ ) - {} - - PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::ePresentTimesInfoGOOGLE; - const void* pNext = nullptr; - uint32_t swapchainCount; - const vk::PresentTimeGOOGLE* pTimes; - }; - static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "layout struct and wrapper have different size!" ); - } - - struct PresentTimesInfoGOOGLE : public layout::PresentTimesInfoGOOGLE + struct PresentTimesInfoGOOGLE { VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0, const vk::PresentTimeGOOGLE* pTimes_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::PresentTimesInfoGOOGLE( swapchainCount_, pTimes_ ) + : swapchainCount( swapchainCount_ ) + , pTimes( pTimes_ ) {} + vk::PresentTimesInfoGOOGLE & operator=( vk::PresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::PresentTimesInfoGOOGLE ) - sizeof( vk::StructureType ) ); + return *this; + } + PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::PresentTimesInfoGOOGLE( rhs ) - {} + { + *this = rhs; + } PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::PresentTimesInfoGOOGLE::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58053,53 +52991,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::PresentTimesInfoGOOGLE::sType; + public: + const vk::StructureType sType = StructureType::ePresentTimesInfoGOOGLE; + const void* pNext = nullptr; + uint32_t swapchainCount; + const vk::PresentTimeGOOGLE* pTimes; }; static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ProtectedSubmitInfo - { - protected: - VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( vk::Bool32 protectedSubmit_ = 0 ) VULKAN_HPP_NOEXCEPT - : protectedSubmit( protectedSubmit_ ) - {} - - ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eProtectedSubmitInfo; - const void* pNext = nullptr; - vk::Bool32 protectedSubmit; - }; - static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "layout struct and wrapper have different size!" ); - } - - struct ProtectedSubmitInfo : public layout::ProtectedSubmitInfo + struct ProtectedSubmitInfo { VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( vk::Bool32 protectedSubmit_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::ProtectedSubmitInfo( protectedSubmit_ ) + : protectedSubmit( protectedSubmit_ ) {} + vk::ProtectedSubmitInfo & operator=( vk::ProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ProtectedSubmitInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ProtectedSubmitInfo( rhs ) - {} + { + *this = rhs; + } ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ProtectedSubmitInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58137,65 +53057,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ProtectedSubmitInfo::sType; + public: + const vk::StructureType sType = StructureType::eProtectedSubmitInfo; + const void* pNext = nullptr; + vk::Bool32 protectedSubmit; }; static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct QueryPoolCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( vk::QueryPoolCreateFlags flags_ = vk::QueryPoolCreateFlags(), - vk::QueryType queryType_ = vk::QueryType::eOcclusion, - uint32_t queryCount_ = 0, - vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , queryType( queryType_ ) - , queryCount( queryCount_ ) - , pipelineStatistics( pipelineStatistics_ ) - {} - - QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eQueryPoolCreateInfo; - const void* pNext = nullptr; - vk::QueryPoolCreateFlags flags; - vk::QueryType queryType; - uint32_t queryCount; - vk::QueryPipelineStatisticFlags pipelineStatistics; - }; - static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct QueryPoolCreateInfo : public layout::QueryPoolCreateInfo + struct QueryPoolCreateInfo { VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( vk::QueryPoolCreateFlags flags_ = vk::QueryPoolCreateFlags(), vk::QueryType queryType_ = vk::QueryType::eOcclusion, uint32_t queryCount_ = 0, vk::QueryPipelineStatisticFlags pipelineStatistics_ = vk::QueryPipelineStatisticFlags() ) VULKAN_HPP_NOEXCEPT - : layout::QueryPoolCreateInfo( flags_, queryType_, queryCount_, pipelineStatistics_ ) + : flags( flags_ ) + , queryType( queryType_ ) + , queryCount( queryCount_ ) + , pipelineStatistics( pipelineStatistics_ ) {} + vk::QueryPoolCreateInfo & operator=( vk::QueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::QueryPoolCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::QueryPoolCreateInfo( rhs ) - {} + { + *this = rhs; + } QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::QueryPoolCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58254,53 +53149,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::QueryPoolCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eQueryPoolCreateInfo; + const void* pNext = nullptr; + vk::QueryPoolCreateFlags flags; + vk::QueryType queryType; + uint32_t queryCount; + vk::QueryPipelineStatisticFlags pipelineStatistics; }; static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct QueryPoolCreateInfoINTEL - { - protected: - VULKAN_HPP_CONSTEXPR QueryPoolCreateInfoINTEL( vk::QueryPoolSamplingModeINTEL performanceCountersSampling_ = vk::QueryPoolSamplingModeINTEL::eManual ) VULKAN_HPP_NOEXCEPT - : performanceCountersSampling( performanceCountersSampling_ ) - {} - - QueryPoolCreateInfoINTEL( VkQueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - QueryPoolCreateInfoINTEL& operator=( VkQueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eQueryPoolCreateInfoINTEL; - const void* pNext = nullptr; - vk::QueryPoolSamplingModeINTEL performanceCountersSampling; - }; - static_assert( sizeof( QueryPoolCreateInfoINTEL ) == sizeof( VkQueryPoolCreateInfoINTEL ), "layout struct and wrapper have different size!" ); - } - - struct QueryPoolCreateInfoINTEL : public layout::QueryPoolCreateInfoINTEL + struct QueryPoolCreateInfoINTEL { VULKAN_HPP_CONSTEXPR QueryPoolCreateInfoINTEL( vk::QueryPoolSamplingModeINTEL performanceCountersSampling_ = vk::QueryPoolSamplingModeINTEL::eManual ) VULKAN_HPP_NOEXCEPT - : layout::QueryPoolCreateInfoINTEL( performanceCountersSampling_ ) + : performanceCountersSampling( performanceCountersSampling_ ) {} + vk::QueryPoolCreateInfoINTEL & operator=( vk::QueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::QueryPoolCreateInfoINTEL ) - sizeof( vk::StructureType ) ); + return *this; + } + QueryPoolCreateInfoINTEL( VkQueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::QueryPoolCreateInfoINTEL( rhs ) - {} + { + *this = rhs; + } QueryPoolCreateInfoINTEL& operator=( VkQueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::QueryPoolCreateInfoINTEL::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58338,52 +53217,119 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::QueryPoolCreateInfoINTEL::sType; + public: + const vk::StructureType sType = StructureType::eQueryPoolCreateInfoINTEL; + const void* pNext = nullptr; + vk::QueryPoolSamplingModeINTEL performanceCountersSampling; }; static_assert( sizeof( QueryPoolCreateInfoINTEL ) == sizeof( VkQueryPoolCreateInfoINTEL ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct QueryPoolPerformanceCreateInfoKHR { - struct QueueFamilyCheckpointPropertiesNV - { - protected: - QueueFamilyCheckpointPropertiesNV() VULKAN_HPP_NOEXCEPT - {} - - QueueFamilyCheckpointPropertiesNV( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - QueueFamilyCheckpointPropertiesNV& operator=( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV; - void* pNext = nullptr; - vk::PipelineStageFlags checkpointExecutionStageMask; - }; - static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "layout struct and wrapper have different size!" ); - } - - struct QueueFamilyCheckpointPropertiesNV : public layout::QueueFamilyCheckpointPropertiesNV - { - QueueFamilyCheckpointPropertiesNV() VULKAN_HPP_NOEXCEPT - : layout::QueueFamilyCheckpointPropertiesNV() + VULKAN_HPP_CONSTEXPR QueryPoolPerformanceCreateInfoKHR( uint32_t queueFamilyIndex_ = 0, + uint32_t counterIndexCount_ = 0, + const uint32_t* pCounterIndices_ = nullptr ) VULKAN_HPP_NOEXCEPT + : queueFamilyIndex( queueFamilyIndex_ ) + , counterIndexCount( counterIndexCount_ ) + , pCounterIndices( pCounterIndices_ ) {} + vk::QueryPoolPerformanceCreateInfoKHR & operator=( vk::QueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::QueryPoolPerformanceCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + + QueryPoolPerformanceCreateInfoKHR( VkQueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = rhs; + } + + QueryPoolPerformanceCreateInfoKHR& operator=( VkQueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast(&rhs); + return *this; + } + + QueryPoolPerformanceCreateInfoKHR & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + QueryPoolPerformanceCreateInfoKHR & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) VULKAN_HPP_NOEXCEPT + { + queueFamilyIndex = queueFamilyIndex_; + return *this; + } + + QueryPoolPerformanceCreateInfoKHR & setCounterIndexCount( uint32_t counterIndexCount_ ) VULKAN_HPP_NOEXCEPT + { + counterIndexCount = counterIndexCount_; + return *this; + } + + QueryPoolPerformanceCreateInfoKHR & setPCounterIndices( const uint32_t* pCounterIndices_ ) VULKAN_HPP_NOEXCEPT + { + pCounterIndices = pCounterIndices_; + return *this; + } + + operator VkQueryPoolPerformanceCreateInfoKHR const&() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueryPoolPerformanceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + bool operator==( QueryPoolPerformanceCreateInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( queueFamilyIndex == rhs.queueFamilyIndex ) + && ( counterIndexCount == rhs.counterIndexCount ) + && ( pCounterIndices == rhs.pCounterIndices ); + } + + bool operator!=( QueryPoolPerformanceCreateInfoKHR const& rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + const vk::StructureType sType = StructureType::eQueryPoolPerformanceCreateInfoKHR; + const void* pNext = nullptr; + 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::value, "struct wrapper is not a standard layout!" ); + + struct QueueFamilyCheckpointPropertiesNV + { + QueueFamilyCheckpointPropertiesNV( vk::PipelineStageFlags checkpointExecutionStageMask_ = vk::PipelineStageFlags() ) VULKAN_HPP_NOEXCEPT + : checkpointExecutionStageMask( checkpointExecutionStageMask_ ) + {} + + vk::QueueFamilyCheckpointPropertiesNV & operator=( vk::QueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::QueueFamilyCheckpointPropertiesNV ) - sizeof( vk::StructureType ) ); + return *this; + } + QueueFamilyCheckpointPropertiesNV( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::QueueFamilyCheckpointPropertiesNV( rhs ) - {} + { + *this = rhs; + } QueueFamilyCheckpointPropertiesNV& operator=( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::QueueFamilyCheckpointPropertiesNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58409,25 +53355,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::QueueFamilyCheckpointPropertiesNV::sType; + public: + const vk::StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV; + void* pNext = nullptr; + vk::PipelineStageFlags checkpointExecutionStageMask; }; static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct QueueFamilyProperties { - QueueFamilyProperties() VULKAN_HPP_NOEXCEPT + QueueFamilyProperties( vk::QueueFlags queueFlags_ = vk::QueueFlags(), + uint32_t queueCount_ = 0, + uint32_t timestampValidBits_ = 0, + vk::Extent3D minImageTransferGranularity_ = vk::Extent3D() ) VULKAN_HPP_NOEXCEPT + : queueFlags( queueFlags_ ) + , queueCount( queueCount_ ) + , timestampValidBits( timestampValidBits_ ) + , minImageTransferGranularity( minImageTransferGranularity_ ) {} QueueFamilyProperties( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } QueueFamilyProperties& operator=( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -58463,46 +53418,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct QueueFamilyProperties2 { - struct QueueFamilyProperties2 - { - protected: - QueueFamilyProperties2() VULKAN_HPP_NOEXCEPT - {} - - QueueFamilyProperties2( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - QueueFamilyProperties2& operator=( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eQueueFamilyProperties2; - void* pNext = nullptr; - vk::QueueFamilyProperties queueFamilyProperties; - }; - static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "layout struct and wrapper have different size!" ); - } - - struct QueueFamilyProperties2 : public layout::QueueFamilyProperties2 - { - QueueFamilyProperties2() VULKAN_HPP_NOEXCEPT - : layout::QueueFamilyProperties2() + QueueFamilyProperties2( vk::QueueFamilyProperties queueFamilyProperties_ = vk::QueueFamilyProperties() ) VULKAN_HPP_NOEXCEPT + : queueFamilyProperties( queueFamilyProperties_ ) {} + vk::QueueFamilyProperties2 & operator=( vk::QueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::QueueFamilyProperties2 ) - sizeof( vk::StructureType ) ); + return *this; + } + QueueFamilyProperties2( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::QueueFamilyProperties2( rhs ) - {} + { + *this = rhs; + } QueueFamilyProperties2& operator=( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::QueueFamilyProperties2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58528,69 +53463,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::QueueFamilyProperties2::sType; + public: + const vk::StructureType sType = StructureType::eQueueFamilyProperties2; + void* pNext = nullptr; + vk::QueueFamilyProperties queueFamilyProperties; }; static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RayTracingShaderGroupCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( vk::RayTracingShaderGroupTypeNV type_ = vk::RayTracingShaderGroupTypeNV::eGeneral, - uint32_t generalShader_ = 0, - uint32_t closestHitShader_ = 0, - uint32_t anyHitShader_ = 0, - uint32_t intersectionShader_ = 0 ) VULKAN_HPP_NOEXCEPT - : type( type_ ) - , generalShader( generalShader_ ) - , closestHitShader( closestHitShader_ ) - , anyHitShader( anyHitShader_ ) - , intersectionShader( intersectionShader_ ) - {} - - RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV; - const void* pNext = nullptr; - vk::RayTracingShaderGroupTypeNV type; - uint32_t generalShader; - uint32_t closestHitShader; - uint32_t anyHitShader; - uint32_t intersectionShader; - }; - static_assert( sizeof( RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct RayTracingShaderGroupCreateInfoNV : public layout::RayTracingShaderGroupCreateInfoNV + struct RayTracingShaderGroupCreateInfoNV { VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( vk::RayTracingShaderGroupTypeNV type_ = vk::RayTracingShaderGroupTypeNV::eGeneral, uint32_t generalShader_ = 0, uint32_t closestHitShader_ = 0, uint32_t anyHitShader_ = 0, uint32_t intersectionShader_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::RayTracingShaderGroupCreateInfoNV( type_, generalShader_, closestHitShader_, anyHitShader_, intersectionShader_ ) + : type( type_ ) + , generalShader( generalShader_ ) + , closestHitShader( closestHitShader_ ) + , anyHitShader( anyHitShader_ ) + , intersectionShader( intersectionShader_ ) {} + vk::RayTracingShaderGroupCreateInfoNV & operator=( vk::RayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RayTracingShaderGroupCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RayTracingShaderGroupCreateInfoNV( rhs ) - {} + { + *this = rhs; + } RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RayTracingShaderGroupCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58656,65 +53564,19 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RayTracingShaderGroupCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV; + const void* pNext = nullptr; + vk::RayTracingShaderGroupTypeNV type; + uint32_t generalShader; + 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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RayTracingPipelineCreateInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(), - uint32_t stageCount_ = 0, - const vk::PipelineShaderStageCreateInfo* pStages_ = nullptr, - uint32_t groupCount_ = 0, - const vk::RayTracingShaderGroupCreateInfoNV* pGroups_ = nullptr, - uint32_t maxRecursionDepth_ = 0, - vk::PipelineLayout layout_ = vk::PipelineLayout(), - vk::Pipeline basePipelineHandle_ = vk::Pipeline(), - int32_t basePipelineIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , stageCount( stageCount_ ) - , pStages( pStages_ ) - , groupCount( groupCount_ ) - , pGroups( pGroups_ ) - , maxRecursionDepth( maxRecursionDepth_ ) - , layout( layout_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - {} - - RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV; - const void* pNext = nullptr; - vk::PipelineCreateFlags flags; - uint32_t stageCount; - const vk::PipelineShaderStageCreateInfo* pStages; - uint32_t groupCount; - const vk::RayTracingShaderGroupCreateInfoNV* pGroups; - uint32_t maxRecursionDepth; - vk::PipelineLayout layout; - vk::Pipeline basePipelineHandle; - int32_t basePipelineIndex; - }; - static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct RayTracingPipelineCreateInfoNV : public layout::RayTracingPipelineCreateInfoNV + struct RayTracingPipelineCreateInfoNV { VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( vk::PipelineCreateFlags flags_ = vk::PipelineCreateFlags(), uint32_t stageCount_ = 0, @@ -58725,16 +53587,31 @@ namespace VULKAN_HPP_NAMESPACE vk::PipelineLayout layout_ = vk::PipelineLayout(), vk::Pipeline basePipelineHandle_ = vk::Pipeline(), int32_t basePipelineIndex_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::RayTracingPipelineCreateInfoNV( flags_, stageCount_, pStages_, groupCount_, pGroups_, maxRecursionDepth_, layout_, basePipelineHandle_, basePipelineIndex_ ) + : flags( flags_ ) + , stageCount( stageCount_ ) + , pStages( pStages_ ) + , groupCount( groupCount_ ) + , pGroups( pGroups_ ) + , maxRecursionDepth( maxRecursionDepth_ ) + , layout( layout_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) {} + vk::RayTracingPipelineCreateInfoNV & operator=( vk::RayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RayTracingPipelineCreateInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RayTracingPipelineCreateInfoNV( rhs ) - {} + { + *this = rhs; + } RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RayTracingPipelineCreateInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58828,25 +53705,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RayTracingPipelineCreateInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV; + const void* pNext = nullptr; + vk::PipelineCreateFlags flags; + uint32_t stageCount; + const vk::PipelineShaderStageCreateInfo* pStages; + uint32_t groupCount; + const vk::RayTracingShaderGroupCreateInfoNV* pGroups; + uint32_t maxRecursionDepth; + vk::PipelineLayout layout; + vk::Pipeline basePipelineHandle; + int32_t basePipelineIndex; }; static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct RefreshCycleDurationGOOGLE { - RefreshCycleDurationGOOGLE() VULKAN_HPP_NOEXCEPT + RefreshCycleDurationGOOGLE( uint64_t refreshDuration_ = 0 ) VULKAN_HPP_NOEXCEPT + : refreshDuration( refreshDuration_ ) {} RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } RefreshCycleDurationGOOGLE& operator=( VkRefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -58876,51 +53764,28 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassAttachmentBeginInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfoKHR( uint32_t attachmentCount_ = 0, - const vk::ImageView* pAttachments_ = nullptr ) VULKAN_HPP_NOEXCEPT - : attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - {} - - RenderPassAttachmentBeginInfoKHR( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassAttachmentBeginInfoKHR& operator=( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassAttachmentBeginInfoKHR; - const void* pNext = nullptr; - uint32_t attachmentCount; - const vk::ImageView* pAttachments; - }; - static_assert( sizeof( RenderPassAttachmentBeginInfoKHR ) == sizeof( VkRenderPassAttachmentBeginInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassAttachmentBeginInfoKHR : public layout::RenderPassAttachmentBeginInfoKHR + struct RenderPassAttachmentBeginInfoKHR { VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfoKHR( uint32_t attachmentCount_ = 0, const vk::ImageView* pAttachments_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassAttachmentBeginInfoKHR( attachmentCount_, pAttachments_ ) + : attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) {} + vk::RenderPassAttachmentBeginInfoKHR & operator=( vk::RenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassAttachmentBeginInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassAttachmentBeginInfoKHR( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassAttachmentBeginInfoKHR( rhs ) - {} + { + *this = rhs; + } RenderPassAttachmentBeginInfoKHR& operator=( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassAttachmentBeginInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -58965,69 +53830,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassAttachmentBeginInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassAttachmentBeginInfoKHR; + const void* pNext = nullptr; + uint32_t attachmentCount; + const vk::ImageView* pAttachments; }; static_assert( sizeof( RenderPassAttachmentBeginInfoKHR ) == sizeof( VkRenderPassAttachmentBeginInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassBeginInfo - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassBeginInfo( vk::RenderPass renderPass_ = vk::RenderPass(), - vk::Framebuffer framebuffer_ = vk::Framebuffer(), - vk::Rect2D renderArea_ = vk::Rect2D(), - uint32_t clearValueCount_ = 0, - const vk::ClearValue* pClearValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : renderPass( renderPass_ ) - , framebuffer( framebuffer_ ) - , renderArea( renderArea_ ) - , clearValueCount( clearValueCount_ ) - , pClearValues( pClearValues_ ) - {} - - RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassBeginInfo; - const void* pNext = nullptr; - vk::RenderPass renderPass; - vk::Framebuffer framebuffer; - vk::Rect2D renderArea; - uint32_t clearValueCount; - const vk::ClearValue* pClearValues; - }; - static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassBeginInfo : public layout::RenderPassBeginInfo + struct RenderPassBeginInfo { VULKAN_HPP_CONSTEXPR RenderPassBeginInfo( vk::RenderPass renderPass_ = vk::RenderPass(), vk::Framebuffer framebuffer_ = vk::Framebuffer(), vk::Rect2D renderArea_ = vk::Rect2D(), uint32_t clearValueCount_ = 0, const vk::ClearValue* pClearValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassBeginInfo( renderPass_, framebuffer_, renderArea_, clearValueCount_, pClearValues_ ) + : renderPass( renderPass_ ) + , framebuffer( framebuffer_ ) + , renderArea( renderArea_ ) + , clearValueCount( clearValueCount_ ) + , pClearValues( pClearValues_ ) {} + vk::RenderPassBeginInfo & operator=( vk::RenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassBeginInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassBeginInfo( rhs ) - {} + { + *this = rhs; + } RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassBeginInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -59093,8 +53932,14 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassBeginInfo::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassBeginInfo; + const void* pNext = nullptr; + vk::RenderPass renderPass; + vk::Framebuffer framebuffer; + vk::Rect2D renderArea; + uint32_t clearValueCount; + const vk::ClearValue* pClearValues; }; static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -59125,12 +53970,12 @@ namespace VULKAN_HPP_NAMESPACE SubpassDescription( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SubpassDescription& operator=( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -59258,12 +54103,12 @@ namespace VULKAN_HPP_NAMESPACE SubpassDependency( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SubpassDependency& operator=( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -59347,53 +54192,7 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(), - uint32_t attachmentCount_ = 0, - const vk::AttachmentDescription* pAttachments_ = nullptr, - uint32_t subpassCount_ = 0, - const vk::SubpassDescription* pSubpasses_ = nullptr, - uint32_t dependencyCount_ = 0, - const vk::SubpassDependency* pDependencies_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - , subpassCount( subpassCount_ ) - , pSubpasses( pSubpasses_ ) - , dependencyCount( dependencyCount_ ) - , pDependencies( pDependencies_ ) - {} - - RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassCreateInfo; - const void* pNext = nullptr; - vk::RenderPassCreateFlags flags; - uint32_t attachmentCount; - const vk::AttachmentDescription* pAttachments; - uint32_t subpassCount; - const vk::SubpassDescription* pSubpasses; - uint32_t dependencyCount; - const vk::SubpassDependency* pDependencies; - }; - static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassCreateInfo : public layout::RenderPassCreateInfo + struct RenderPassCreateInfo { VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(), uint32_t attachmentCount_ = 0, @@ -59402,16 +54201,29 @@ namespace VULKAN_HPP_NAMESPACE const vk::SubpassDescription* pSubpasses_ = nullptr, uint32_t dependencyCount_ = 0, const vk::SubpassDependency* pDependencies_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassCreateInfo( flags_, attachmentCount_, pAttachments_, subpassCount_, pSubpasses_, dependencyCount_, pDependencies_ ) + : flags( flags_ ) + , attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) + , subpassCount( subpassCount_ ) + , pSubpasses( pSubpasses_ ) + , dependencyCount( dependencyCount_ ) + , pDependencies( pDependencies_ ) {} + vk::RenderPassCreateInfo & operator=( vk::RenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassCreateInfo( rhs ) - {} + { + *this = rhs; + } RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -59491,71 +54303,21 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassCreateInfo; + const void* pNext = nullptr; + vk::RenderPassCreateFlags flags; + uint32_t attachmentCount; + const vk::AttachmentDescription* pAttachments; + uint32_t subpassCount; + const vk::SubpassDescription* pSubpasses; + uint32_t dependencyCount; + const vk::SubpassDependency* pDependencies; }; static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SubpassDescription2KHR - { - protected: - VULKAN_HPP_CONSTEXPR SubpassDescription2KHR( vk::SubpassDescriptionFlags flags_ = vk::SubpassDescriptionFlags(), - vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics, - uint32_t viewMask_ = 0, - uint32_t inputAttachmentCount_ = 0, - const vk::AttachmentReference2KHR* pInputAttachments_ = nullptr, - uint32_t colorAttachmentCount_ = 0, - const vk::AttachmentReference2KHR* pColorAttachments_ = nullptr, - const vk::AttachmentReference2KHR* pResolveAttachments_ = nullptr, - const vk::AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr, - uint32_t preserveAttachmentCount_ = 0, - const uint32_t* pPreserveAttachments_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , pipelineBindPoint( pipelineBindPoint_ ) - , viewMask( viewMask_ ) - , inputAttachmentCount( inputAttachmentCount_ ) - , pInputAttachments( pInputAttachments_ ) - , colorAttachmentCount( colorAttachmentCount_ ) - , pColorAttachments( pColorAttachments_ ) - , pResolveAttachments( pResolveAttachments_ ) - , pDepthStencilAttachment( pDepthStencilAttachment_ ) - , preserveAttachmentCount( preserveAttachmentCount_ ) - , pPreserveAttachments( pPreserveAttachments_ ) - {} - - SubpassDescription2KHR( VkSubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSubpassDescription2KHR; - const void* pNext = nullptr; - vk::SubpassDescriptionFlags flags; - vk::PipelineBindPoint pipelineBindPoint; - uint32_t viewMask; - uint32_t inputAttachmentCount; - const vk::AttachmentReference2KHR* pInputAttachments; - uint32_t colorAttachmentCount; - const vk::AttachmentReference2KHR* pColorAttachments; - const vk::AttachmentReference2KHR* pResolveAttachments; - const vk::AttachmentReference2KHR* pDepthStencilAttachment; - uint32_t preserveAttachmentCount; - const uint32_t* pPreserveAttachments; - }; - static_assert( sizeof( SubpassDescription2KHR ) == sizeof( VkSubpassDescription2KHR ), "layout struct and wrapper have different size!" ); - } - - struct SubpassDescription2KHR : public layout::SubpassDescription2KHR + struct SubpassDescription2KHR { VULKAN_HPP_CONSTEXPR SubpassDescription2KHR( vk::SubpassDescriptionFlags flags_ = vk::SubpassDescriptionFlags(), vk::PipelineBindPoint pipelineBindPoint_ = vk::PipelineBindPoint::eGraphics, @@ -59568,16 +54330,33 @@ namespace VULKAN_HPP_NAMESPACE const vk::AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr, uint32_t preserveAttachmentCount_ = 0, const uint32_t* pPreserveAttachments_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::SubpassDescription2KHR( flags_, pipelineBindPoint_, viewMask_, inputAttachmentCount_, pInputAttachments_, colorAttachmentCount_, pColorAttachments_, pResolveAttachments_, pDepthStencilAttachment_, preserveAttachmentCount_, pPreserveAttachments_ ) + : flags( flags_ ) + , pipelineBindPoint( pipelineBindPoint_ ) + , viewMask( viewMask_ ) + , inputAttachmentCount( inputAttachmentCount_ ) + , pInputAttachments( pInputAttachments_ ) + , colorAttachmentCount( colorAttachmentCount_ ) + , pColorAttachments( pColorAttachments_ ) + , pResolveAttachments( pResolveAttachments_ ) + , pDepthStencilAttachment( pDepthStencilAttachment_ ) + , preserveAttachmentCount( preserveAttachmentCount_ ) + , pPreserveAttachments( pPreserveAttachments_ ) {} + vk::SubpassDescription2KHR & operator=( vk::SubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassDescription2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SubpassDescription2KHR( VkSubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SubpassDescription2KHR( rhs ) - {} + { + *this = rhs; + } SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SubpassDescription2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -59685,62 +54464,25 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SubpassDescription2KHR::sType; + public: + const vk::StructureType sType = StructureType::eSubpassDescription2KHR; + const void* pNext = nullptr; + vk::SubpassDescriptionFlags flags; + vk::PipelineBindPoint pipelineBindPoint; + uint32_t viewMask; + uint32_t inputAttachmentCount; + const vk::AttachmentReference2KHR* pInputAttachments; + uint32_t colorAttachmentCount; + const vk::AttachmentReference2KHR* pColorAttachments; + const vk::AttachmentReference2KHR* pResolveAttachments; + const vk::AttachmentReference2KHR* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; }; static_assert( sizeof( SubpassDescription2KHR ) == sizeof( VkSubpassDescription2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SubpassDependency2KHR - { - protected: - VULKAN_HPP_CONSTEXPR SubpassDependency2KHR( uint32_t srcSubpass_ = 0, - uint32_t dstSubpass_ = 0, - vk::PipelineStageFlags srcStageMask_ = vk::PipelineStageFlags(), - vk::PipelineStageFlags dstStageMask_ = vk::PipelineStageFlags(), - vk::AccessFlags srcAccessMask_ = vk::AccessFlags(), - vk::AccessFlags dstAccessMask_ = vk::AccessFlags(), - vk::DependencyFlags dependencyFlags_ = vk::DependencyFlags(), - int32_t viewOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : srcSubpass( srcSubpass_ ) - , dstSubpass( dstSubpass_ ) - , srcStageMask( srcStageMask_ ) - , dstStageMask( dstStageMask_ ) - , srcAccessMask( srcAccessMask_ ) - , dstAccessMask( dstAccessMask_ ) - , dependencyFlags( dependencyFlags_ ) - , viewOffset( viewOffset_ ) - {} - - SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSubpassDependency2KHR; - const void* pNext = nullptr; - uint32_t srcSubpass; - uint32_t dstSubpass; - vk::PipelineStageFlags srcStageMask; - vk::PipelineStageFlags dstStageMask; - vk::AccessFlags srcAccessMask; - vk::AccessFlags dstAccessMask; - vk::DependencyFlags dependencyFlags; - int32_t viewOffset; - }; - static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "layout struct and wrapper have different size!" ); - } - - struct SubpassDependency2KHR : public layout::SubpassDependency2KHR + struct SubpassDependency2KHR { VULKAN_HPP_CONSTEXPR SubpassDependency2KHR( uint32_t srcSubpass_ = 0, uint32_t dstSubpass_ = 0, @@ -59750,16 +54492,30 @@ namespace VULKAN_HPP_NAMESPACE vk::AccessFlags dstAccessMask_ = vk::AccessFlags(), vk::DependencyFlags dependencyFlags_ = vk::DependencyFlags(), int32_t viewOffset_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SubpassDependency2KHR( srcSubpass_, dstSubpass_, srcStageMask_, dstStageMask_, srcAccessMask_, dstAccessMask_, dependencyFlags_, viewOffset_ ) + : srcSubpass( srcSubpass_ ) + , dstSubpass( dstSubpass_ ) + , srcStageMask( srcStageMask_ ) + , dstStageMask( dstStageMask_ ) + , srcAccessMask( srcAccessMask_ ) + , dstAccessMask( dstAccessMask_ ) + , dependencyFlags( dependencyFlags_ ) + , viewOffset( viewOffset_ ) {} + vk::SubpassDependency2KHR & operator=( vk::SubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassDependency2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SubpassDependency2KHR( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SubpassDependency2KHR( rhs ) - {} + { + *this = rhs; + } SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SubpassDependency2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -59846,65 +54602,22 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SubpassDependency2KHR::sType; + public: + const vk::StructureType sType = StructureType::eSubpassDependency2KHR; + const void* pNext = nullptr; + uint32_t srcSubpass; + uint32_t dstSubpass; + vk::PipelineStageFlags srcStageMask; + vk::PipelineStageFlags dstStageMask; + vk::AccessFlags srcAccessMask; + vk::AccessFlags dstAccessMask; + vk::DependencyFlags dependencyFlags; + int32_t viewOffset; }; static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassCreateInfo2KHR - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2KHR( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(), - uint32_t attachmentCount_ = 0, - const vk::AttachmentDescription2KHR* pAttachments_ = nullptr, - uint32_t subpassCount_ = 0, - const vk::SubpassDescription2KHR* pSubpasses_ = nullptr, - uint32_t dependencyCount_ = 0, - const vk::SubpassDependency2KHR* pDependencies_ = nullptr, - uint32_t correlatedViewMaskCount_ = 0, - const uint32_t* pCorrelatedViewMasks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , attachmentCount( attachmentCount_ ) - , pAttachments( pAttachments_ ) - , subpassCount( subpassCount_ ) - , pSubpasses( pSubpasses_ ) - , dependencyCount( dependencyCount_ ) - , pDependencies( pDependencies_ ) - , correlatedViewMaskCount( correlatedViewMaskCount_ ) - , pCorrelatedViewMasks( pCorrelatedViewMasks_ ) - {} - - RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassCreateInfo2KHR; - const void* pNext = nullptr; - vk::RenderPassCreateFlags flags; - uint32_t attachmentCount; - const vk::AttachmentDescription2KHR* pAttachments; - uint32_t subpassCount; - const vk::SubpassDescription2KHR* pSubpasses; - uint32_t dependencyCount; - const vk::SubpassDependency2KHR* pDependencies; - uint32_t correlatedViewMaskCount; - const uint32_t* pCorrelatedViewMasks; - }; - static_assert( sizeof( RenderPassCreateInfo2KHR ) == sizeof( VkRenderPassCreateInfo2KHR ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassCreateInfo2KHR : public layout::RenderPassCreateInfo2KHR + struct RenderPassCreateInfo2KHR { VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2KHR( vk::RenderPassCreateFlags flags_ = vk::RenderPassCreateFlags(), uint32_t attachmentCount_ = 0, @@ -59915,16 +54628,31 @@ namespace VULKAN_HPP_NAMESPACE const vk::SubpassDependency2KHR* pDependencies_ = nullptr, uint32_t correlatedViewMaskCount_ = 0, const uint32_t* pCorrelatedViewMasks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassCreateInfo2KHR( flags_, attachmentCount_, pAttachments_, subpassCount_, pSubpasses_, dependencyCount_, pDependencies_, correlatedViewMaskCount_, pCorrelatedViewMasks_ ) + : flags( flags_ ) + , attachmentCount( attachmentCount_ ) + , pAttachments( pAttachments_ ) + , subpassCount( subpassCount_ ) + , pSubpasses( pSubpasses_ ) + , dependencyCount( dependencyCount_ ) + , pDependencies( pDependencies_ ) + , correlatedViewMaskCount( correlatedViewMaskCount_ ) + , pCorrelatedViewMasks( pCorrelatedViewMasks_ ) {} + vk::RenderPassCreateInfo2KHR & operator=( vk::RenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassCreateInfo2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassCreateInfo2KHR( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassCreateInfo2KHR( rhs ) - {} + { + *this = rhs; + } RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassCreateInfo2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60018,53 +54746,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassCreateInfo2KHR::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassCreateInfo2KHR; + const void* pNext = nullptr; + vk::RenderPassCreateFlags flags; + uint32_t attachmentCount; + const vk::AttachmentDescription2KHR* pAttachments; + uint32_t subpassCount; + const vk::SubpassDescription2KHR* pSubpasses; + uint32_t dependencyCount; + const vk::SubpassDependency2KHR* pDependencies; + uint32_t correlatedViewMaskCount; + const uint32_t* pCorrelatedViewMasks; }; static_assert( sizeof( RenderPassCreateInfo2KHR ) == sizeof( VkRenderPassCreateInfo2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassFragmentDensityMapCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( vk::AttachmentReference fragmentDensityMapAttachment_ = vk::AttachmentReference() ) VULKAN_HPP_NOEXCEPT - : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ ) - {} - - RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT; - const void* pNext = nullptr; - vk::AttachmentReference fragmentDensityMapAttachment; - }; - static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassFragmentDensityMapCreateInfoEXT : public layout::RenderPassFragmentDensityMapCreateInfoEXT + struct RenderPassFragmentDensityMapCreateInfoEXT { VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( vk::AttachmentReference fragmentDensityMapAttachment_ = vk::AttachmentReference() ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassFragmentDensityMapCreateInfoEXT( fragmentDensityMapAttachment_ ) + : fragmentDensityMapAttachment( fragmentDensityMapAttachment_ ) {} + vk::RenderPassFragmentDensityMapCreateInfoEXT & operator=( vk::RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassFragmentDensityMapCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassFragmentDensityMapCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassFragmentDensityMapCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60102,57 +54819,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassFragmentDensityMapCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT; + const void* pNext = nullptr; + vk::AttachmentReference fragmentDensityMapAttachment; }; static_assert( sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassInputAttachmentAspectCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0, - const vk::InputAttachmentAspectReference* pAspectReferences_ = nullptr ) VULKAN_HPP_NOEXCEPT - : aspectReferenceCount( aspectReferenceCount_ ) - , pAspectReferences( pAspectReferences_ ) - {} - - RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo; - const void* pNext = nullptr; - uint32_t aspectReferenceCount; - const vk::InputAttachmentAspectReference* pAspectReferences; - }; - static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassInputAttachmentAspectCreateInfo : public layout::RenderPassInputAttachmentAspectCreateInfo + struct RenderPassInputAttachmentAspectCreateInfo { VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = 0, const vk::InputAttachmentAspectReference* pAspectReferences_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassInputAttachmentAspectCreateInfo( aspectReferenceCount_, pAspectReferences_ ) + : aspectReferenceCount( aspectReferenceCount_ ) + , pAspectReferences( pAspectReferences_ ) {} + vk::RenderPassInputAttachmentAspectCreateInfo & operator=( vk::RenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassInputAttachmentAspectCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassInputAttachmentAspectCreateInfo( rhs ) - {} + { + *this = rhs; + } RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassInputAttachmentAspectCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60197,56 +54893,16 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassInputAttachmentAspectCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo; + const void* pNext = nullptr; + uint32_t aspectReferenceCount; + const vk::InputAttachmentAspectReference* pAspectReferences; }; static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassMultiviewCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = 0, - const uint32_t* pViewMasks_ = nullptr, - uint32_t dependencyCount_ = 0, - const int32_t* pViewOffsets_ = nullptr, - uint32_t correlationMaskCount_ = 0, - const uint32_t* pCorrelationMasks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : subpassCount( subpassCount_ ) - , pViewMasks( pViewMasks_ ) - , dependencyCount( dependencyCount_ ) - , pViewOffsets( pViewOffsets_ ) - , correlationMaskCount( correlationMaskCount_ ) - , pCorrelationMasks( pCorrelationMasks_ ) - {} - - RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassMultiviewCreateInfo; - const void* pNext = nullptr; - uint32_t subpassCount; - const uint32_t* pViewMasks; - uint32_t dependencyCount; - const int32_t* pViewOffsets; - uint32_t correlationMaskCount; - const uint32_t* pCorrelationMasks; - }; - static_assert( sizeof( RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassMultiviewCreateInfo : public layout::RenderPassMultiviewCreateInfo + struct RenderPassMultiviewCreateInfo { VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = 0, const uint32_t* pViewMasks_ = nullptr, @@ -60254,16 +54910,28 @@ namespace VULKAN_HPP_NAMESPACE const int32_t* pViewOffsets_ = nullptr, uint32_t correlationMaskCount_ = 0, const uint32_t* pCorrelationMasks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassMultiviewCreateInfo( subpassCount_, pViewMasks_, dependencyCount_, pViewOffsets_, correlationMaskCount_, pCorrelationMasks_ ) + : subpassCount( subpassCount_ ) + , pViewMasks( pViewMasks_ ) + , dependencyCount( dependencyCount_ ) + , pViewOffsets( pViewOffsets_ ) + , correlationMaskCount( correlationMaskCount_ ) + , pCorrelationMasks( pCorrelationMasks_ ) {} + vk::RenderPassMultiviewCreateInfo & operator=( vk::RenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassMultiviewCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassMultiviewCreateInfo( rhs ) - {} + { + *this = rhs; + } RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassMultiviewCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60336,8 +55004,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassMultiviewCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassMultiviewCreateInfo; + const void* pNext = nullptr; + uint32_t subpassCount; + const uint32_t* pViewMasks; + uint32_t dependencyCount; + 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::value, "struct wrapper is not a standard layout!" ); @@ -60352,12 +55027,12 @@ namespace VULKAN_HPP_NAMESPACE SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SubpassSampleLocationsEXT& operator=( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -60401,59 +55076,32 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct RenderPassSampleLocationsBeginInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0, - const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr, - uint32_t postSubpassSampleLocationsCount_ = 0, - const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr ) VULKAN_HPP_NOEXCEPT - : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ ) - , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ ) - , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ ) - , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ ) - {} - - RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT; - const void* pNext = nullptr; - uint32_t attachmentInitialSampleLocationsCount; - const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; - uint32_t postSubpassSampleLocationsCount; - const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations; - }; - static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct RenderPassSampleLocationsBeginInfoEXT : public layout::RenderPassSampleLocationsBeginInfoEXT + struct RenderPassSampleLocationsBeginInfoEXT { VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0, const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr, uint32_t postSubpassSampleLocationsCount_ = 0, const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassSampleLocationsBeginInfoEXT( attachmentInitialSampleLocationsCount_, pAttachmentInitialSampleLocations_, postSubpassSampleLocationsCount_, pPostSubpassSampleLocations_ ) + : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ ) + , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ ) + , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ ) + , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ ) {} + vk::RenderPassSampleLocationsBeginInfoEXT & operator=( vk::RenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::RenderPassSampleLocationsBeginInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::RenderPassSampleLocationsBeginInfoEXT( rhs ) - {} + { + *this = rhs; + } RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::RenderPassSampleLocationsBeginInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60512,86 +55160,18 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::RenderPassSampleLocationsBeginInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT; + const void* pNext = nullptr; + uint32_t attachmentInitialSampleLocationsCount; + const vk::AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; + uint32_t postSubpassSampleLocationsCount; + const vk::SubpassSampleLocationsEXT* pPostSubpassSampleLocations; }; static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SamplerCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR SamplerCreateInfo( vk::SamplerCreateFlags flags_ = vk::SamplerCreateFlags(), - vk::Filter magFilter_ = vk::Filter::eNearest, - vk::Filter minFilter_ = vk::Filter::eNearest, - vk::SamplerMipmapMode mipmapMode_ = vk::SamplerMipmapMode::eNearest, - vk::SamplerAddressMode addressModeU_ = vk::SamplerAddressMode::eRepeat, - vk::SamplerAddressMode addressModeV_ = vk::SamplerAddressMode::eRepeat, - vk::SamplerAddressMode addressModeW_ = vk::SamplerAddressMode::eRepeat, - float mipLodBias_ = 0, - vk::Bool32 anisotropyEnable_ = 0, - float maxAnisotropy_ = 0, - vk::Bool32 compareEnable_ = 0, - vk::CompareOp compareOp_ = vk::CompareOp::eNever, - float minLod_ = 0, - float maxLod_ = 0, - vk::BorderColor borderColor_ = vk::BorderColor::eFloatTransparentBlack, - vk::Bool32 unnormalizedCoordinates_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , magFilter( magFilter_ ) - , minFilter( minFilter_ ) - , mipmapMode( mipmapMode_ ) - , addressModeU( addressModeU_ ) - , addressModeV( addressModeV_ ) - , addressModeW( addressModeW_ ) - , mipLodBias( mipLodBias_ ) - , anisotropyEnable( anisotropyEnable_ ) - , maxAnisotropy( maxAnisotropy_ ) - , compareEnable( compareEnable_ ) - , compareOp( compareOp_ ) - , minLod( minLod_ ) - , maxLod( maxLod_ ) - , borderColor( borderColor_ ) - , unnormalizedCoordinates( unnormalizedCoordinates_ ) - {} - - SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSamplerCreateInfo; - const void* pNext = nullptr; - vk::SamplerCreateFlags flags; - vk::Filter magFilter; - vk::Filter minFilter; - vk::SamplerMipmapMode mipmapMode; - vk::SamplerAddressMode addressModeU; - vk::SamplerAddressMode addressModeV; - vk::SamplerAddressMode addressModeW; - float mipLodBias; - vk::Bool32 anisotropyEnable; - float maxAnisotropy; - vk::Bool32 compareEnable; - vk::CompareOp compareOp; - float minLod; - float maxLod; - vk::BorderColor borderColor; - vk::Bool32 unnormalizedCoordinates; - }; - static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct SamplerCreateInfo : public layout::SamplerCreateInfo + struct SamplerCreateInfo { VULKAN_HPP_CONSTEXPR SamplerCreateInfo( vk::SamplerCreateFlags flags_ = vk::SamplerCreateFlags(), vk::Filter magFilter_ = vk::Filter::eNearest, @@ -60609,16 +55189,38 @@ namespace VULKAN_HPP_NAMESPACE float maxLod_ = 0, vk::BorderColor borderColor_ = vk::BorderColor::eFloatTransparentBlack, vk::Bool32 unnormalizedCoordinates_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SamplerCreateInfo( flags_, magFilter_, minFilter_, mipmapMode_, addressModeU_, addressModeV_, addressModeW_, mipLodBias_, anisotropyEnable_, maxAnisotropy_, compareEnable_, compareOp_, minLod_, maxLod_, borderColor_, unnormalizedCoordinates_ ) + : flags( flags_ ) + , magFilter( magFilter_ ) + , minFilter( minFilter_ ) + , mipmapMode( mipmapMode_ ) + , addressModeU( addressModeU_ ) + , addressModeV( addressModeV_ ) + , addressModeW( addressModeW_ ) + , mipLodBias( mipLodBias_ ) + , anisotropyEnable( anisotropyEnable_ ) + , maxAnisotropy( maxAnisotropy_ ) + , compareEnable( compareEnable_ ) + , compareOp( compareOp_ ) + , minLod( minLod_ ) + , maxLod( maxLod_ ) + , borderColor( borderColor_ ) + , unnormalizedCoordinates( unnormalizedCoordinates_ ) {} + vk::SamplerCreateInfo & operator=( vk::SamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SamplerCreateInfo( rhs ) - {} + { + *this = rhs; + } SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SamplerCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60761,53 +55363,49 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SamplerCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eSamplerCreateInfo; + const void* pNext = nullptr; + vk::SamplerCreateFlags flags; + vk::Filter magFilter; + vk::Filter minFilter; + vk::SamplerMipmapMode mipmapMode; + vk::SamplerAddressMode addressModeU; + vk::SamplerAddressMode addressModeV; + vk::SamplerAddressMode addressModeW; + float mipLodBias; + vk::Bool32 anisotropyEnable; + float maxAnisotropy; + vk::Bool32 compareEnable; + vk::CompareOp compareOp; + float minLod; + float maxLod; + vk::BorderColor borderColor; + vk::Bool32 unnormalizedCoordinates; }; static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SamplerReductionModeCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfoEXT( vk::SamplerReductionModeEXT reductionMode_ = vk::SamplerReductionModeEXT::eWeightedAverage ) VULKAN_HPP_NOEXCEPT - : reductionMode( reductionMode_ ) - {} - - SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT; - const void* pNext = nullptr; - vk::SamplerReductionModeEXT reductionMode; - }; - static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct SamplerReductionModeCreateInfoEXT : public layout::SamplerReductionModeCreateInfoEXT + struct SamplerReductionModeCreateInfoEXT { VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfoEXT( vk::SamplerReductionModeEXT reductionMode_ = vk::SamplerReductionModeEXT::eWeightedAverage ) VULKAN_HPP_NOEXCEPT - : layout::SamplerReductionModeCreateInfoEXT( reductionMode_ ) + : reductionMode( reductionMode_ ) {} + vk::SamplerReductionModeCreateInfoEXT & operator=( vk::SamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerReductionModeCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SamplerReductionModeCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SamplerReductionModeCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -60845,62 +55443,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SamplerReductionModeCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT; + const void* pNext = nullptr; + vk::SamplerReductionModeEXT reductionMode; }; static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SamplerYcbcrConversionCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( vk::Format format_ = vk::Format::eUndefined, - vk::SamplerYcbcrModelConversion ycbcrModel_ = vk::SamplerYcbcrModelConversion::eRgbIdentity, - vk::SamplerYcbcrRange ycbcrRange_ = vk::SamplerYcbcrRange::eItuFull, - vk::ComponentMapping components_ = vk::ComponentMapping(), - vk::ChromaLocation xChromaOffset_ = vk::ChromaLocation::eCositedEven, - vk::ChromaLocation yChromaOffset_ = vk::ChromaLocation::eCositedEven, - vk::Filter chromaFilter_ = vk::Filter::eNearest, - vk::Bool32 forceExplicitReconstruction_ = 0 ) VULKAN_HPP_NOEXCEPT - : format( format_ ) - , ycbcrModel( ycbcrModel_ ) - , ycbcrRange( ycbcrRange_ ) - , components( components_ ) - , xChromaOffset( xChromaOffset_ ) - , yChromaOffset( yChromaOffset_ ) - , chromaFilter( chromaFilter_ ) - , forceExplicitReconstruction( forceExplicitReconstruction_ ) - {} - - SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo; - const void* pNext = nullptr; - vk::Format format; - vk::SamplerYcbcrModelConversion ycbcrModel; - vk::SamplerYcbcrRange ycbcrRange; - vk::ComponentMapping components; - vk::ChromaLocation xChromaOffset; - vk::ChromaLocation yChromaOffset; - vk::Filter chromaFilter; - vk::Bool32 forceExplicitReconstruction; - }; - static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct SamplerYcbcrConversionCreateInfo : public layout::SamplerYcbcrConversionCreateInfo + struct SamplerYcbcrConversionCreateInfo { VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( vk::Format format_ = vk::Format::eUndefined, vk::SamplerYcbcrModelConversion ycbcrModel_ = vk::SamplerYcbcrModelConversion::eRgbIdentity, @@ -60910,16 +55461,30 @@ namespace VULKAN_HPP_NAMESPACE vk::ChromaLocation yChromaOffset_ = vk::ChromaLocation::eCositedEven, vk::Filter chromaFilter_ = vk::Filter::eNearest, vk::Bool32 forceExplicitReconstruction_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SamplerYcbcrConversionCreateInfo( format_, ycbcrModel_, ycbcrRange_, components_, xChromaOffset_, yChromaOffset_, chromaFilter_, forceExplicitReconstruction_ ) + : format( format_ ) + , ycbcrModel( ycbcrModel_ ) + , ycbcrRange( ycbcrRange_ ) + , components( components_ ) + , xChromaOffset( xChromaOffset_ ) + , yChromaOffset( yChromaOffset_ ) + , chromaFilter( chromaFilter_ ) + , forceExplicitReconstruction( forceExplicitReconstruction_ ) {} + vk::SamplerYcbcrConversionCreateInfo & operator=( vk::SamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerYcbcrConversionCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SamplerYcbcrConversionCreateInfo( rhs ) - {} + { + *this = rhs; + } SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SamplerYcbcrConversionCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61006,52 +55571,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SamplerYcbcrConversionCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo; + const void* pNext = nullptr; + vk::Format format; + vk::SamplerYcbcrModelConversion ycbcrModel; + vk::SamplerYcbcrRange ycbcrRange; + vk::ComponentMapping components; + vk::ChromaLocation xChromaOffset; + vk::ChromaLocation yChromaOffset; + vk::Filter chromaFilter; + vk::Bool32 forceExplicitReconstruction; }; static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct SamplerYcbcrConversionImageFormatProperties { - struct SamplerYcbcrConversionImageFormatProperties - { - protected: - SamplerYcbcrConversionImageFormatProperties() VULKAN_HPP_NOEXCEPT - {} - - SamplerYcbcrConversionImageFormatProperties( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SamplerYcbcrConversionImageFormatProperties& operator=( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties; - void* pNext = nullptr; - uint32_t combinedImageSamplerDescriptorCount; - }; - static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "layout struct and wrapper have different size!" ); - } - - struct SamplerYcbcrConversionImageFormatProperties : public layout::SamplerYcbcrConversionImageFormatProperties - { - SamplerYcbcrConversionImageFormatProperties() VULKAN_HPP_NOEXCEPT - : layout::SamplerYcbcrConversionImageFormatProperties() + SamplerYcbcrConversionImageFormatProperties( uint32_t combinedImageSamplerDescriptorCount_ = 0 ) VULKAN_HPP_NOEXCEPT + : combinedImageSamplerDescriptorCount( combinedImageSamplerDescriptorCount_ ) {} + vk::SamplerYcbcrConversionImageFormatProperties & operator=( vk::SamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerYcbcrConversionImageFormatProperties ) - sizeof( vk::StructureType ) ); + return *this; + } + SamplerYcbcrConversionImageFormatProperties( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SamplerYcbcrConversionImageFormatProperties( rhs ) - {} + { + *this = rhs; + } SamplerYcbcrConversionImageFormatProperties& operator=( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SamplerYcbcrConversionImageFormatProperties::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61077,53 +55631,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SamplerYcbcrConversionImageFormatProperties::sType; + public: + const vk::StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties; + void* pNext = nullptr; + uint32_t combinedImageSamplerDescriptorCount; }; static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SamplerYcbcrConversionInfo - { - protected: - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( vk::SamplerYcbcrConversion conversion_ = vk::SamplerYcbcrConversion() ) VULKAN_HPP_NOEXCEPT - : conversion( conversion_ ) - {} - - SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSamplerYcbcrConversionInfo; - const void* pNext = nullptr; - vk::SamplerYcbcrConversion conversion; - }; - static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "layout struct and wrapper have different size!" ); - } - - struct SamplerYcbcrConversionInfo : public layout::SamplerYcbcrConversionInfo + struct SamplerYcbcrConversionInfo { VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( vk::SamplerYcbcrConversion conversion_ = vk::SamplerYcbcrConversion() ) VULKAN_HPP_NOEXCEPT - : layout::SamplerYcbcrConversionInfo( conversion_ ) + : conversion( conversion_ ) {} + vk::SamplerYcbcrConversionInfo & operator=( vk::SamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SamplerYcbcrConversionInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SamplerYcbcrConversionInfo( rhs ) - {} + { + *this = rhs; + } SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SamplerYcbcrConversionInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61161,53 +55696,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SamplerYcbcrConversionInfo::sType; + public: + const vk::StructureType sType = StructureType::eSamplerYcbcrConversionInfo; + const void* pNext = nullptr; + vk::SamplerYcbcrConversion conversion; }; static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SemaphoreCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( vk::SemaphoreCreateFlags flags_ = vk::SemaphoreCreateFlags() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - {} - - SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSemaphoreCreateInfo; - const void* pNext = nullptr; - vk::SemaphoreCreateFlags flags; - }; - static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct SemaphoreCreateInfo : public layout::SemaphoreCreateInfo + struct SemaphoreCreateInfo { VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( vk::SemaphoreCreateFlags flags_ = vk::SemaphoreCreateFlags() ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreCreateInfo( flags_ ) + : flags( flags_ ) {} + vk::SemaphoreCreateInfo & operator=( vk::SemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreCreateInfo( rhs ) - {} + { + *this = rhs; + } SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SemaphoreCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61245,57 +55761,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SemaphoreCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eSemaphoreCreateInfo; + const void* pNext = nullptr; + vk::SemaphoreCreateFlags flags; }; static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SemaphoreGetFdInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), - vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : semaphore( semaphore_ ) - , handleType( handleType_ ) - {} - - SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSemaphoreGetFdInfoKHR; - const void* pNext = nullptr; - vk::Semaphore semaphore; - vk::ExternalSemaphoreHandleTypeFlagBits handleType; - }; - static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SemaphoreGetFdInfoKHR : public layout::SemaphoreGetFdInfoKHR + struct SemaphoreGetFdInfoKHR { VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreGetFdInfoKHR( semaphore_, handleType_ ) + : semaphore( semaphore_ ) + , handleType( handleType_ ) {} + vk::SemaphoreGetFdInfoKHR & operator=( vk::SemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreGetFdInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreGetFdInfoKHR( rhs ) - {} + { + *this = rhs; + } SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SemaphoreGetFdInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61340,59 +55835,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SemaphoreGetFdInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSemaphoreGetFdInfoKHR; + const void* pNext = nullptr; + vk::Semaphore semaphore; + vk::ExternalSemaphoreHandleTypeFlagBits handleType; }; static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct SemaphoreGetWin32HandleInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), - vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : semaphore( semaphore_ ) - , handleType( handleType_ ) - {} - - SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR; - const void* pNext = nullptr; - vk::Semaphore semaphore; - vk::ExternalSemaphoreHandleTypeFlagBits handleType; - }; - static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SemaphoreGetWin32HandleInfoKHR : public layout::SemaphoreGetWin32HandleInfoKHR + struct SemaphoreGetWin32HandleInfoKHR { VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), vk::ExternalSemaphoreHandleTypeFlagBits handleType_ = vk::ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreGetWin32HandleInfoKHR( semaphore_, handleType_ ) + : semaphore( semaphore_ ) + , handleType( handleType_ ) {} + vk::SemaphoreGetWin32HandleInfoKHR & operator=( vk::SemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreGetWin32HandleInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreGetWin32HandleInfoKHR( rhs ) - {} + { + *this = rhs; + } SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SemaphoreGetWin32HandleInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61437,58 +55912,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SemaphoreGetWin32HandleInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR; + const void* pNext = nullptr; + vk::Semaphore semaphore; + vk::ExternalSemaphoreHandleTypeFlagBits handleType; }; static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct SemaphoreSignalInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SemaphoreSignalInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), - uint64_t value_ = 0 ) VULKAN_HPP_NOEXCEPT - : semaphore( semaphore_ ) - , value( value_ ) - {} - - SemaphoreSignalInfoKHR( VkSemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SemaphoreSignalInfoKHR& operator=( VkSemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSemaphoreSignalInfoKHR; - const void* pNext = nullptr; - vk::Semaphore semaphore; - uint64_t value; - }; - static_assert( sizeof( SemaphoreSignalInfoKHR ) == sizeof( VkSemaphoreSignalInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SemaphoreSignalInfoKHR : public layout::SemaphoreSignalInfoKHR + struct SemaphoreSignalInfoKHR { VULKAN_HPP_CONSTEXPR SemaphoreSignalInfoKHR( vk::Semaphore semaphore_ = vk::Semaphore(), uint64_t value_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreSignalInfoKHR( semaphore_, value_ ) + : semaphore( semaphore_ ) + , value( value_ ) {} + vk::SemaphoreSignalInfoKHR & operator=( vk::SemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreSignalInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SemaphoreSignalInfoKHR( VkSemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreSignalInfoKHR( rhs ) - {} + { + *this = rhs; + } SemaphoreSignalInfoKHR& operator=( VkSemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SemaphoreSignalInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61533,57 +55988,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SemaphoreSignalInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSemaphoreSignalInfoKHR; + const void* pNext = nullptr; + vk::Semaphore semaphore; + uint64_t value; }; static_assert( sizeof( SemaphoreSignalInfoKHR ) == sizeof( VkSemaphoreSignalInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SemaphoreTypeCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfoKHR( vk::SemaphoreTypeKHR semaphoreType_ = vk::SemaphoreTypeKHR::eBinary, - uint64_t initialValue_ = 0 ) VULKAN_HPP_NOEXCEPT - : semaphoreType( semaphoreType_ ) - , initialValue( initialValue_ ) - {} - - SemaphoreTypeCreateInfoKHR( VkSemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SemaphoreTypeCreateInfoKHR& operator=( VkSemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSemaphoreTypeCreateInfoKHR; - const void* pNext = nullptr; - vk::SemaphoreTypeKHR semaphoreType; - uint64_t initialValue; - }; - static_assert( sizeof( SemaphoreTypeCreateInfoKHR ) == sizeof( VkSemaphoreTypeCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SemaphoreTypeCreateInfoKHR : public layout::SemaphoreTypeCreateInfoKHR + struct SemaphoreTypeCreateInfoKHR { VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfoKHR( vk::SemaphoreTypeKHR semaphoreType_ = vk::SemaphoreTypeKHR::eBinary, uint64_t initialValue_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreTypeCreateInfoKHR( semaphoreType_, initialValue_ ) + : semaphoreType( semaphoreType_ ) + , initialValue( initialValue_ ) {} + vk::SemaphoreTypeCreateInfoKHR & operator=( vk::SemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreTypeCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SemaphoreTypeCreateInfoKHR( VkSemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreTypeCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } SemaphoreTypeCreateInfoKHR& operator=( VkSemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SemaphoreTypeCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61628,65 +56063,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SemaphoreTypeCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSemaphoreTypeCreateInfoKHR; + const void* pNext = nullptr; + vk::SemaphoreTypeKHR semaphoreType; + uint64_t initialValue; }; static_assert( sizeof( SemaphoreTypeCreateInfoKHR ) == sizeof( VkSemaphoreTypeCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SemaphoreWaitInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SemaphoreWaitInfoKHR( vk::SemaphoreWaitFlagsKHR flags_ = vk::SemaphoreWaitFlagsKHR(), - uint32_t semaphoreCount_ = 0, - const vk::Semaphore* pSemaphores_ = nullptr, - const uint64_t* pValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , semaphoreCount( semaphoreCount_ ) - , pSemaphores( pSemaphores_ ) - , pValues( pValues_ ) - {} - - SemaphoreWaitInfoKHR( VkSemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SemaphoreWaitInfoKHR& operator=( VkSemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSemaphoreWaitInfoKHR; - const void* pNext = nullptr; - vk::SemaphoreWaitFlagsKHR flags; - uint32_t semaphoreCount; - const vk::Semaphore* pSemaphores; - const uint64_t* pValues; - }; - static_assert( sizeof( SemaphoreWaitInfoKHR ) == sizeof( VkSemaphoreWaitInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SemaphoreWaitInfoKHR : public layout::SemaphoreWaitInfoKHR + struct SemaphoreWaitInfoKHR { VULKAN_HPP_CONSTEXPR SemaphoreWaitInfoKHR( vk::SemaphoreWaitFlagsKHR flags_ = vk::SemaphoreWaitFlagsKHR(), uint32_t semaphoreCount_ = 0, const vk::Semaphore* pSemaphores_ = nullptr, const uint64_t* pValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreWaitInfoKHR( flags_, semaphoreCount_, pSemaphores_, pValues_ ) + : flags( flags_ ) + , semaphoreCount( semaphoreCount_ ) + , pSemaphores( pSemaphores_ ) + , pValues( pValues_ ) {} + vk::SemaphoreWaitInfoKHR & operator=( vk::SemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SemaphoreWaitInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SemaphoreWaitInfoKHR( VkSemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SemaphoreWaitInfoKHR( rhs ) - {} + { + *this = rhs; + } SemaphoreWaitInfoKHR& operator=( VkSemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SemaphoreWaitInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61745,61 +56156,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SemaphoreWaitInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSemaphoreWaitInfoKHR; + const void* pNext = nullptr; + vk::SemaphoreWaitFlagsKHR flags; + uint32_t semaphoreCount; + const vk::Semaphore* pSemaphores; + const uint64_t* pValues; }; static_assert( sizeof( SemaphoreWaitInfoKHR ) == sizeof( VkSemaphoreWaitInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ShaderModuleCreateInfo - { - protected: - VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( vk::ShaderModuleCreateFlags flags_ = vk::ShaderModuleCreateFlags(), - size_t codeSize_ = 0, - const uint32_t* pCode_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , codeSize( codeSize_ ) - , pCode( pCode_ ) - {} - - ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eShaderModuleCreateInfo; - const void* pNext = nullptr; - vk::ShaderModuleCreateFlags flags; - size_t codeSize; - const uint32_t* pCode; - }; - static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "layout struct and wrapper have different size!" ); - } - - struct ShaderModuleCreateInfo : public layout::ShaderModuleCreateInfo + struct ShaderModuleCreateInfo { VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( vk::ShaderModuleCreateFlags flags_ = vk::ShaderModuleCreateFlags(), size_t codeSize_ = 0, const uint32_t* pCode_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ShaderModuleCreateInfo( flags_, codeSize_, pCode_ ) + : flags( flags_ ) + , codeSize( codeSize_ ) + , pCode( pCode_ ) {} + vk::ShaderModuleCreateInfo & operator=( vk::ShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ShaderModuleCreateInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ShaderModuleCreateInfo( rhs ) - {} + { + *this = rhs; + } ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ShaderModuleCreateInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61851,53 +56242,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ShaderModuleCreateInfo::sType; + public: + const vk::StructureType sType = StructureType::eShaderModuleCreateInfo; + const void* pNext = nullptr; + vk::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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ShaderModuleValidationCacheCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( vk::ValidationCacheEXT validationCache_ = vk::ValidationCacheEXT() ) VULKAN_HPP_NOEXCEPT - : validationCache( validationCache_ ) - {} - - ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT; - const void* pNext = nullptr; - vk::ValidationCacheEXT validationCache; - }; - static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct ShaderModuleValidationCacheCreateInfoEXT : public layout::ShaderModuleValidationCacheCreateInfoEXT + struct ShaderModuleValidationCacheCreateInfoEXT { VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( vk::ValidationCacheEXT validationCache_ = vk::ValidationCacheEXT() ) VULKAN_HPP_NOEXCEPT - : layout::ShaderModuleValidationCacheCreateInfoEXT( validationCache_ ) + : validationCache( validationCache_ ) {} + vk::ShaderModuleValidationCacheCreateInfoEXT & operator=( vk::ShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ShaderModuleValidationCacheCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ShaderModuleValidationCacheCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ShaderModuleValidationCacheCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -61935,25 +56309,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ShaderModuleValidationCacheCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT; + const void* pNext = nullptr; + vk::ValidationCacheEXT validationCache; }; static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct ShaderResourceUsageAMD { - ShaderResourceUsageAMD() VULKAN_HPP_NOEXCEPT + ShaderResourceUsageAMD( uint32_t numUsedVgprs_ = 0, + uint32_t numUsedSgprs_ = 0, + uint32_t ldsSizePerLocalWorkGroup_ = 0, + size_t ldsUsageSizeInBytes_ = 0, + size_t scratchMemUsageInBytes_ = 0 ) VULKAN_HPP_NOEXCEPT + : numUsedVgprs( numUsedVgprs_ ) + , numUsedSgprs( numUsedSgprs_ ) + , ldsSizePerLocalWorkGroup( ldsSizePerLocalWorkGroup_ ) + , ldsUsageSizeInBytes( ldsUsageSizeInBytes_ ) + , scratchMemUsageInBytes( scratchMemUsageInBytes_ ) {} ShaderResourceUsageAMD( VkShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ShaderResourceUsageAMD& operator=( VkShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -61993,17 +56378,32 @@ namespace VULKAN_HPP_NAMESPACE struct ShaderStatisticsInfoAMD { - ShaderStatisticsInfoAMD() VULKAN_HPP_NOEXCEPT - {} + ShaderStatisticsInfoAMD( vk::ShaderStageFlags shaderStageMask_ = vk::ShaderStageFlags(), + vk::ShaderResourceUsageAMD resourceUsage_ = vk::ShaderResourceUsageAMD(), + uint32_t numPhysicalVgprs_ = 0, + uint32_t numPhysicalSgprs_ = 0, + uint32_t numAvailableVgprs_ = 0, + uint32_t numAvailableSgprs_ = 0, + std::array const& computeWorkGroupSize_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT + : shaderStageMask( shaderStageMask_ ) + , resourceUsage( resourceUsage_ ) + , numPhysicalVgprs( numPhysicalVgprs_ ) + , numPhysicalSgprs( numPhysicalSgprs_ ) + , numAvailableVgprs( numAvailableVgprs_ ) + , numAvailableSgprs( numAvailableSgprs_ ) + , computeWorkGroupSize{} + { + vk::ConstExpressionArrayCopy::copy( computeWorkGroupSize, computeWorkGroupSize_ ); + } ShaderStatisticsInfoAMD( VkShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } ShaderStatisticsInfoAMD& operator=( VkShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -62045,46 +56445,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct SharedPresentSurfaceCapabilitiesKHR { - struct SharedPresentSurfaceCapabilitiesKHR - { - protected: - SharedPresentSurfaceCapabilitiesKHR() VULKAN_HPP_NOEXCEPT - {} - - SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SharedPresentSurfaceCapabilitiesKHR& operator=( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR; - void* pNext = nullptr; - vk::ImageUsageFlags sharedPresentSupportedUsageFlags; - }; - static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct SharedPresentSurfaceCapabilitiesKHR : public layout::SharedPresentSurfaceCapabilitiesKHR - { - SharedPresentSurfaceCapabilitiesKHR() VULKAN_HPP_NOEXCEPT - : layout::SharedPresentSurfaceCapabilitiesKHR() + SharedPresentSurfaceCapabilitiesKHR( vk::ImageUsageFlags sharedPresentSupportedUsageFlags_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT + : sharedPresentSupportedUsageFlags( sharedPresentSupportedUsageFlags_ ) {} + vk::SharedPresentSurfaceCapabilitiesKHR & operator=( vk::SharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SharedPresentSurfaceCapabilitiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SharedPresentSurfaceCapabilitiesKHR( rhs ) - {} + { + *this = rhs; + } SharedPresentSurfaceCapabilitiesKHR& operator=( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SharedPresentSurfaceCapabilitiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62110,25 +56490,32 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SharedPresentSurfaceCapabilitiesKHR::sType; + public: + const vk::StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR; + void* pNext = nullptr; + vk::ImageUsageFlags sharedPresentSupportedUsageFlags; }; static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct SparseImageFormatProperties { - SparseImageFormatProperties() VULKAN_HPP_NOEXCEPT + SparseImageFormatProperties( vk::ImageAspectFlags aspectMask_ = vk::ImageAspectFlags(), + vk::Extent3D imageGranularity_ = vk::Extent3D(), + vk::SparseImageFormatFlags flags_ = vk::SparseImageFormatFlags() ) VULKAN_HPP_NOEXCEPT + : aspectMask( aspectMask_ ) + , imageGranularity( imageGranularity_ ) + , flags( flags_ ) {} SparseImageFormatProperties( VkSparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SparseImageFormatProperties& operator=( VkSparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -62162,46 +56549,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct SparseImageFormatProperties2 { - struct SparseImageFormatProperties2 - { - protected: - SparseImageFormatProperties2() VULKAN_HPP_NOEXCEPT - {} - - SparseImageFormatProperties2( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SparseImageFormatProperties2& operator=( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSparseImageFormatProperties2; - void* pNext = nullptr; - vk::SparseImageFormatProperties properties; - }; - static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "layout struct and wrapper have different size!" ); - } - - struct SparseImageFormatProperties2 : public layout::SparseImageFormatProperties2 - { - SparseImageFormatProperties2() VULKAN_HPP_NOEXCEPT - : layout::SparseImageFormatProperties2() + SparseImageFormatProperties2( vk::SparseImageFormatProperties properties_ = vk::SparseImageFormatProperties() ) VULKAN_HPP_NOEXCEPT + : properties( properties_ ) {} + vk::SparseImageFormatProperties2 & operator=( vk::SparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SparseImageFormatProperties2 ) - sizeof( vk::StructureType ) ); + return *this; + } + SparseImageFormatProperties2( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SparseImageFormatProperties2( rhs ) - {} + { + *this = rhs; + } SparseImageFormatProperties2& operator=( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SparseImageFormatProperties2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62227,25 +56594,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SparseImageFormatProperties2::sType; + public: + const vk::StructureType sType = StructureType::eSparseImageFormatProperties2; + void* pNext = nullptr; + vk::SparseImageFormatProperties properties; }; static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct SparseImageMemoryRequirements { - SparseImageMemoryRequirements() VULKAN_HPP_NOEXCEPT + SparseImageMemoryRequirements( vk::SparseImageFormatProperties formatProperties_ = vk::SparseImageFormatProperties(), + uint32_t imageMipTailFirstLod_ = 0, + vk::DeviceSize imageMipTailSize_ = 0, + vk::DeviceSize imageMipTailOffset_ = 0, + vk::DeviceSize imageMipTailStride_ = 0 ) VULKAN_HPP_NOEXCEPT + : formatProperties( formatProperties_ ) + , imageMipTailFirstLod( imageMipTailFirstLod_ ) + , imageMipTailSize( imageMipTailSize_ ) + , imageMipTailOffset( imageMipTailOffset_ ) + , imageMipTailStride( imageMipTailStride_ ) {} SparseImageMemoryRequirements( VkSparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SparseImageMemoryRequirements& operator=( VkSparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -62283,46 +56661,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct SparseImageMemoryRequirements2 { - struct SparseImageMemoryRequirements2 - { - protected: - SparseImageMemoryRequirements2() VULKAN_HPP_NOEXCEPT - {} - - SparseImageMemoryRequirements2( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SparseImageMemoryRequirements2& operator=( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSparseImageMemoryRequirements2; - void* pNext = nullptr; - vk::SparseImageMemoryRequirements memoryRequirements; - }; - static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "layout struct and wrapper have different size!" ); - } - - struct SparseImageMemoryRequirements2 : public layout::SparseImageMemoryRequirements2 - { - SparseImageMemoryRequirements2() VULKAN_HPP_NOEXCEPT - : layout::SparseImageMemoryRequirements2() + SparseImageMemoryRequirements2( vk::SparseImageMemoryRequirements memoryRequirements_ = vk::SparseImageMemoryRequirements() ) VULKAN_HPP_NOEXCEPT + : memoryRequirements( memoryRequirements_ ) {} + vk::SparseImageMemoryRequirements2 & operator=( vk::SparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SparseImageMemoryRequirements2 ) - sizeof( vk::StructureType ) ); + return *this; + } + SparseImageMemoryRequirements2( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SparseImageMemoryRequirements2( rhs ) - {} + { + *this = rhs; + } SparseImageMemoryRequirements2& operator=( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SparseImageMemoryRequirements2::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62348,59 +56706,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SparseImageMemoryRequirements2::sType; + public: + const vk::StructureType sType = StructureType::eSparseImageMemoryRequirements2; + void* pNext = nullptr; + vk::SparseImageMemoryRequirements memoryRequirements; }; static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_GGP - namespace layout - { - struct StreamDescriptorSurfaceCreateInfoGGP - { - protected: - VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( vk::StreamDescriptorSurfaceCreateFlagsGGP flags_ = vk::StreamDescriptorSurfaceCreateFlagsGGP(), - GgpStreamDescriptor streamDescriptor_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , streamDescriptor( streamDescriptor_ ) - {} - - StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - StreamDescriptorSurfaceCreateInfoGGP& operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP; - const void* pNext = nullptr; - vk::StreamDescriptorSurfaceCreateFlagsGGP flags; - GgpStreamDescriptor streamDescriptor; - }; - static_assert( sizeof( StreamDescriptorSurfaceCreateInfoGGP ) == sizeof( VkStreamDescriptorSurfaceCreateInfoGGP ), "layout struct and wrapper have different size!" ); - } - - struct StreamDescriptorSurfaceCreateInfoGGP : public layout::StreamDescriptorSurfaceCreateInfoGGP + struct StreamDescriptorSurfaceCreateInfoGGP { VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( vk::StreamDescriptorSurfaceCreateFlagsGGP flags_ = vk::StreamDescriptorSurfaceCreateFlagsGGP(), GgpStreamDescriptor streamDescriptor_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::StreamDescriptorSurfaceCreateInfoGGP( flags_, streamDescriptor_ ) + : flags( flags_ ) + , streamDescriptor( streamDescriptor_ ) {} + vk::StreamDescriptorSurfaceCreateInfoGGP & operator=( vk::StreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::StreamDescriptorSurfaceCreateInfoGGP ) - sizeof( vk::StructureType ) ); + return *this; + } + StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::StreamDescriptorSurfaceCreateInfoGGP( rhs ) - {} + { + *this = rhs; + } StreamDescriptorSurfaceCreateInfoGGP& operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::StreamDescriptorSurfaceCreateInfoGGP::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62445,60 +56782,17 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::StreamDescriptorSurfaceCreateInfoGGP::sType; + public: + const vk::StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP; + const void* pNext = nullptr; + vk::StreamDescriptorSurfaceCreateFlagsGGP flags; + GgpStreamDescriptor streamDescriptor; }; static_assert( sizeof( StreamDescriptorSurfaceCreateInfoGGP ) == sizeof( VkStreamDescriptorSurfaceCreateInfoGGP ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_GGP*/ - namespace layout - { - struct SubmitInfo - { - protected: - VULKAN_HPP_CONSTEXPR SubmitInfo( uint32_t waitSemaphoreCount_ = 0, - const vk::Semaphore* pWaitSemaphores_ = nullptr, - const vk::PipelineStageFlags* pWaitDstStageMask_ = nullptr, - uint32_t commandBufferCount_ = 0, - const vk::CommandBuffer* pCommandBuffers_ = nullptr, - uint32_t signalSemaphoreCount_ = 0, - const vk::Semaphore* pSignalSemaphores_ = nullptr ) VULKAN_HPP_NOEXCEPT - : waitSemaphoreCount( waitSemaphoreCount_ ) - , pWaitSemaphores( pWaitSemaphores_ ) - , pWaitDstStageMask( pWaitDstStageMask_ ) - , commandBufferCount( commandBufferCount_ ) - , pCommandBuffers( pCommandBuffers_ ) - , signalSemaphoreCount( signalSemaphoreCount_ ) - , pSignalSemaphores( pSignalSemaphores_ ) - {} - - SubmitInfo( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SubmitInfo& operator=( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSubmitInfo; - const void* pNext = nullptr; - uint32_t waitSemaphoreCount; - const vk::Semaphore* pWaitSemaphores; - const vk::PipelineStageFlags* pWaitDstStageMask; - uint32_t commandBufferCount; - const vk::CommandBuffer* pCommandBuffers; - uint32_t signalSemaphoreCount; - const vk::Semaphore* pSignalSemaphores; - }; - static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "layout struct and wrapper have different size!" ); - } - - struct SubmitInfo : public layout::SubmitInfo + struct SubmitInfo { VULKAN_HPP_CONSTEXPR SubmitInfo( uint32_t waitSemaphoreCount_ = 0, const vk::Semaphore* pWaitSemaphores_ = nullptr, @@ -62507,16 +56801,29 @@ namespace VULKAN_HPP_NAMESPACE const vk::CommandBuffer* pCommandBuffers_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const vk::Semaphore* pSignalSemaphores_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::SubmitInfo( waitSemaphoreCount_, pWaitSemaphores_, pWaitDstStageMask_, commandBufferCount_, pCommandBuffers_, signalSemaphoreCount_, pSignalSemaphores_ ) + : waitSemaphoreCount( waitSemaphoreCount_ ) + , pWaitSemaphores( pWaitSemaphores_ ) + , pWaitDstStageMask( pWaitDstStageMask_ ) + , commandBufferCount( commandBufferCount_ ) + , pCommandBuffers( pCommandBuffers_ ) + , signalSemaphoreCount( signalSemaphoreCount_ ) + , pSignalSemaphores( pSignalSemaphores_ ) {} + vk::SubmitInfo & operator=( vk::SubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SubmitInfo ) - sizeof( vk::StructureType ) ); + return *this; + } + SubmitInfo( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SubmitInfo( rhs ) - {} + { + *this = rhs; + } SubmitInfo& operator=( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SubmitInfo::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62596,53 +56903,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SubmitInfo::sType; + public: + const vk::StructureType sType = StructureType::eSubmitInfo; + const void* pNext = nullptr; + uint32_t waitSemaphoreCount; + const vk::Semaphore* pWaitSemaphores; + const vk::PipelineStageFlags* pWaitDstStageMask; + uint32_t commandBufferCount; + const vk::CommandBuffer* pCommandBuffers; + uint32_t signalSemaphoreCount; + const vk::Semaphore* pSignalSemaphores; }; static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SubpassBeginInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SubpassBeginInfoKHR( vk::SubpassContents contents_ = vk::SubpassContents::eInline ) VULKAN_HPP_NOEXCEPT - : contents( contents_ ) - {} - - SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSubpassBeginInfoKHR; - const void* pNext = nullptr; - vk::SubpassContents contents; - }; - static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SubpassBeginInfoKHR : public layout::SubpassBeginInfoKHR + struct SubpassBeginInfoKHR { VULKAN_HPP_CONSTEXPR SubpassBeginInfoKHR( vk::SubpassContents contents_ = vk::SubpassContents::eInline ) VULKAN_HPP_NOEXCEPT - : layout::SubpassBeginInfoKHR( contents_ ) + : contents( contents_ ) {} + vk::SubpassBeginInfoKHR & operator=( vk::SubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassBeginInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SubpassBeginInfoKHR( VkSubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SubpassBeginInfoKHR( rhs ) - {} + { + *this = rhs; + } SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SubpassBeginInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62680,61 +56974,38 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SubpassBeginInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSubpassBeginInfoKHR; + const void* pNext = nullptr; + vk::SubpassContents contents; }; static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SubpassDescriptionDepthStencilResolveKHR - { - protected: - VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolveKHR( vk::ResolveModeFlagBitsKHR depthResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone, - vk::ResolveModeFlagBitsKHR stencilResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone, - const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment_ = nullptr ) VULKAN_HPP_NOEXCEPT - : depthResolveMode( depthResolveMode_ ) - , stencilResolveMode( stencilResolveMode_ ) - , pDepthStencilResolveAttachment( pDepthStencilResolveAttachment_ ) - {} - - SubpassDescriptionDepthStencilResolveKHR( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SubpassDescriptionDepthStencilResolveKHR& operator=( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSubpassDescriptionDepthStencilResolveKHR; - const void* pNext = nullptr; - vk::ResolveModeFlagBitsKHR depthResolveMode; - vk::ResolveModeFlagBitsKHR stencilResolveMode; - const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment; - }; - static_assert( sizeof( SubpassDescriptionDepthStencilResolveKHR ) == sizeof( VkSubpassDescriptionDepthStencilResolveKHR ), "layout struct and wrapper have different size!" ); - } - - struct SubpassDescriptionDepthStencilResolveKHR : public layout::SubpassDescriptionDepthStencilResolveKHR + struct SubpassDescriptionDepthStencilResolveKHR { VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolveKHR( vk::ResolveModeFlagBitsKHR depthResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone, vk::ResolveModeFlagBitsKHR stencilResolveMode_ = vk::ResolveModeFlagBitsKHR::eNone, const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::SubpassDescriptionDepthStencilResolveKHR( depthResolveMode_, stencilResolveMode_, pDepthStencilResolveAttachment_ ) + : depthResolveMode( depthResolveMode_ ) + , stencilResolveMode( stencilResolveMode_ ) + , pDepthStencilResolveAttachment( pDepthStencilResolveAttachment_ ) {} + vk::SubpassDescriptionDepthStencilResolveKHR & operator=( vk::SubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassDescriptionDepthStencilResolveKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SubpassDescriptionDepthStencilResolveKHR( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SubpassDescriptionDepthStencilResolveKHR( rhs ) - {} + { + *this = rhs; + } SubpassDescriptionDepthStencilResolveKHR& operator=( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SubpassDescriptionDepthStencilResolveKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62786,51 +57057,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SubpassDescriptionDepthStencilResolveKHR::sType; + public: + const vk::StructureType sType = StructureType::eSubpassDescriptionDepthStencilResolveKHR; + const void* pNext = nullptr; + vk::ResolveModeFlagBitsKHR depthResolveMode; + vk::ResolveModeFlagBitsKHR stencilResolveMode; + const vk::AttachmentReference2KHR* pDepthStencilResolveAttachment; }; static_assert( sizeof( SubpassDescriptionDepthStencilResolveKHR ) == sizeof( VkSubpassDescriptionDepthStencilResolveKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SubpassEndInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SubpassEndInfoKHR() VULKAN_HPP_NOEXCEPT - {} - - SubpassEndInfoKHR( VkSubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SubpassEndInfoKHR& operator=( VkSubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSubpassEndInfoKHR; - const void* pNext = nullptr; - }; - static_assert( sizeof( SubpassEndInfoKHR ) == sizeof( VkSubpassEndInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SubpassEndInfoKHR : public layout::SubpassEndInfoKHR + struct SubpassEndInfoKHR { VULKAN_HPP_CONSTEXPR SubpassEndInfoKHR() VULKAN_HPP_NOEXCEPT - : layout::SubpassEndInfoKHR() {} + vk::SubpassEndInfoKHR & operator=( vk::SubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SubpassEndInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SubpassEndInfoKHR( VkSubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SubpassEndInfoKHR( rhs ) - {} + { + *this = rhs; + } SubpassEndInfoKHR& operator=( VkSubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SubpassEndInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62861,62 +57116,53 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SubpassEndInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSubpassEndInfoKHR; + const void* pNext = nullptr; }; static_assert( sizeof( SubpassEndInfoKHR ) == sizeof( VkSubpassEndInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct SurfaceCapabilities2EXT { - struct SurfaceCapabilities2EXT - { - protected: - SurfaceCapabilities2EXT() VULKAN_HPP_NOEXCEPT - {} - - SurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SurfaceCapabilities2EXT& operator=( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSurfaceCapabilities2EXT; - void* pNext = nullptr; - uint32_t minImageCount; - uint32_t maxImageCount; - vk::Extent2D currentExtent; - vk::Extent2D minImageExtent; - vk::Extent2D maxImageExtent; - uint32_t maxImageArrayLayers; - vk::SurfaceTransformFlagsKHR supportedTransforms; - vk::SurfaceTransformFlagBitsKHR currentTransform; - vk::CompositeAlphaFlagsKHR supportedCompositeAlpha; - vk::ImageUsageFlags supportedUsageFlags; - vk::SurfaceCounterFlagsEXT supportedSurfaceCounters; - }; - static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "layout struct and wrapper have different size!" ); - } - - struct SurfaceCapabilities2EXT : public layout::SurfaceCapabilities2EXT - { - SurfaceCapabilities2EXT() VULKAN_HPP_NOEXCEPT - : layout::SurfaceCapabilities2EXT() + SurfaceCapabilities2EXT( uint32_t minImageCount_ = 0, + uint32_t maxImageCount_ = 0, + vk::Extent2D currentExtent_ = vk::Extent2D(), + vk::Extent2D minImageExtent_ = vk::Extent2D(), + vk::Extent2D maxImageExtent_ = vk::Extent2D(), + uint32_t maxImageArrayLayers_ = 0, + vk::SurfaceTransformFlagsKHR supportedTransforms_ = vk::SurfaceTransformFlagsKHR(), + vk::SurfaceTransformFlagBitsKHR currentTransform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity, + vk::CompositeAlphaFlagsKHR supportedCompositeAlpha_ = vk::CompositeAlphaFlagsKHR(), + vk::ImageUsageFlags supportedUsageFlags_ = vk::ImageUsageFlags(), + vk::SurfaceCounterFlagsEXT supportedSurfaceCounters_ = vk::SurfaceCounterFlagsEXT() ) VULKAN_HPP_NOEXCEPT + : minImageCount( minImageCount_ ) + , maxImageCount( maxImageCount_ ) + , currentExtent( currentExtent_ ) + , minImageExtent( minImageExtent_ ) + , maxImageExtent( maxImageExtent_ ) + , maxImageArrayLayers( maxImageArrayLayers_ ) + , supportedTransforms( supportedTransforms_ ) + , currentTransform( currentTransform_ ) + , supportedCompositeAlpha( supportedCompositeAlpha_ ) + , supportedUsageFlags( supportedUsageFlags_ ) + , supportedSurfaceCounters( supportedSurfaceCounters_ ) {} + vk::SurfaceCapabilities2EXT & operator=( vk::SurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceCapabilities2EXT ) - sizeof( vk::StructureType ) ); + return *this; + } + SurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceCapabilities2EXT( rhs ) - {} + { + *this = rhs; + } SurfaceCapabilities2EXT& operator=( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SurfaceCapabilities2EXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -62952,25 +57198,56 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SurfaceCapabilities2EXT::sType; + public: + const vk::StructureType sType = StructureType::eSurfaceCapabilities2EXT; + void* pNext = nullptr; + uint32_t minImageCount; + uint32_t maxImageCount; + vk::Extent2D currentExtent; + vk::Extent2D minImageExtent; + vk::Extent2D maxImageExtent; + uint32_t maxImageArrayLayers; + vk::SurfaceTransformFlagsKHR supportedTransforms; + vk::SurfaceTransformFlagBitsKHR currentTransform; + vk::CompositeAlphaFlagsKHR supportedCompositeAlpha; + vk::ImageUsageFlags supportedUsageFlags; + vk::SurfaceCounterFlagsEXT supportedSurfaceCounters; }; static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); struct SurfaceCapabilitiesKHR { - SurfaceCapabilitiesKHR() VULKAN_HPP_NOEXCEPT + SurfaceCapabilitiesKHR( uint32_t minImageCount_ = 0, + uint32_t maxImageCount_ = 0, + vk::Extent2D currentExtent_ = vk::Extent2D(), + vk::Extent2D minImageExtent_ = vk::Extent2D(), + vk::Extent2D maxImageExtent_ = vk::Extent2D(), + uint32_t maxImageArrayLayers_ = 0, + vk::SurfaceTransformFlagsKHR supportedTransforms_ = vk::SurfaceTransformFlagsKHR(), + vk::SurfaceTransformFlagBitsKHR currentTransform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity, + vk::CompositeAlphaFlagsKHR supportedCompositeAlpha_ = vk::CompositeAlphaFlagsKHR(), + vk::ImageUsageFlags supportedUsageFlags_ = vk::ImageUsageFlags() ) VULKAN_HPP_NOEXCEPT + : minImageCount( minImageCount_ ) + , maxImageCount( maxImageCount_ ) + , currentExtent( currentExtent_ ) + , minImageExtent( minImageExtent_ ) + , maxImageExtent( maxImageExtent_ ) + , maxImageArrayLayers( maxImageArrayLayers_ ) + , supportedTransforms( supportedTransforms_ ) + , currentTransform( currentTransform_ ) + , supportedCompositeAlpha( supportedCompositeAlpha_ ) + , supportedUsageFlags( supportedUsageFlags_ ) {} SurfaceCapabilitiesKHR( VkSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SurfaceCapabilitiesKHR& operator=( VkSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -63018,46 +57295,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct SurfaceCapabilities2KHR { - struct SurfaceCapabilities2KHR - { - protected: - SurfaceCapabilities2KHR() VULKAN_HPP_NOEXCEPT - {} - - SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SurfaceCapabilities2KHR& operator=( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSurfaceCapabilities2KHR; - void* pNext = nullptr; - vk::SurfaceCapabilitiesKHR surfaceCapabilities; - }; - static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "layout struct and wrapper have different size!" ); - } - - struct SurfaceCapabilities2KHR : public layout::SurfaceCapabilities2KHR - { - SurfaceCapabilities2KHR() VULKAN_HPP_NOEXCEPT - : layout::SurfaceCapabilities2KHR() + SurfaceCapabilities2KHR( vk::SurfaceCapabilitiesKHR surfaceCapabilities_ = vk::SurfaceCapabilitiesKHR() ) VULKAN_HPP_NOEXCEPT + : surfaceCapabilities( surfaceCapabilities_ ) {} + vk::SurfaceCapabilities2KHR & operator=( vk::SurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceCapabilities2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceCapabilities2KHR( rhs ) - {} + { + *this = rhs; + } SurfaceCapabilities2KHR& operator=( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SurfaceCapabilities2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63083,55 +57340,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SurfaceCapabilities2KHR::sType; + public: + const vk::StructureType sType = StructureType::eSurfaceCapabilities2KHR; + void* pNext = nullptr; + vk::SurfaceCapabilitiesKHR surfaceCapabilities; }; static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct SurfaceCapabilitiesFullScreenExclusiveEXT - { - protected: - VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( vk::Bool32 fullScreenExclusiveSupported_ = 0 ) VULKAN_HPP_NOEXCEPT - : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ ) - {} - - SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SurfaceCapabilitiesFullScreenExclusiveEXT& operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT; - void* pNext = nullptr; - vk::Bool32 fullScreenExclusiveSupported; - }; - static_assert( sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) == sizeof( VkSurfaceCapabilitiesFullScreenExclusiveEXT ), "layout struct and wrapper have different size!" ); - } - - struct SurfaceCapabilitiesFullScreenExclusiveEXT : public layout::SurfaceCapabilitiesFullScreenExclusiveEXT + struct SurfaceCapabilitiesFullScreenExclusiveEXT { VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( vk::Bool32 fullScreenExclusiveSupported_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceCapabilitiesFullScreenExclusiveEXT( fullScreenExclusiveSupported_ ) + : fullScreenExclusiveSupported( fullScreenExclusiveSupported_ ) {} + vk::SurfaceCapabilitiesFullScreenExclusiveEXT & operator=( vk::SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceCapabilitiesFullScreenExclusiveEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceCapabilitiesFullScreenExclusiveEXT( rhs ) - {} + { + *this = rhs; + } SurfaceCapabilitiesFullScreenExclusiveEXT& operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SurfaceCapabilitiesFullScreenExclusiveEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63169,8 +57407,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SurfaceCapabilitiesFullScreenExclusiveEXT::sType; + public: + const vk::StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT; + void* pNext = nullptr; + vk::Bool32 fullScreenExclusiveSupported; }; static_assert( sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) == sizeof( VkSurfaceCapabilitiesFullScreenExclusiveEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -63178,17 +57418,20 @@ namespace VULKAN_HPP_NAMESPACE struct SurfaceFormatKHR { - SurfaceFormatKHR() VULKAN_HPP_NOEXCEPT + SurfaceFormatKHR( vk::Format format_ = vk::Format::eUndefined, + vk::ColorSpaceKHR colorSpace_ = vk::ColorSpaceKHR::eSrgbNonlinear ) VULKAN_HPP_NOEXCEPT + : format( format_ ) + , colorSpace( colorSpace_ ) {} SurfaceFormatKHR( VkSurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = rhs; } SurfaceFormatKHR& operator=( VkSurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *reinterpret_cast(this) = rhs; + *this = *reinterpret_cast(&rhs); return *this; } @@ -63220,46 +57463,26 @@ namespace VULKAN_HPP_NAMESPACE static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct SurfaceFormat2KHR { - struct SurfaceFormat2KHR - { - protected: - SurfaceFormat2KHR() VULKAN_HPP_NOEXCEPT - {} - - SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SurfaceFormat2KHR& operator=( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSurfaceFormat2KHR; - void* pNext = nullptr; - vk::SurfaceFormatKHR surfaceFormat; - }; - static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "layout struct and wrapper have different size!" ); - } - - struct SurfaceFormat2KHR : public layout::SurfaceFormat2KHR - { - SurfaceFormat2KHR() VULKAN_HPP_NOEXCEPT - : layout::SurfaceFormat2KHR() + SurfaceFormat2KHR( vk::SurfaceFormatKHR surfaceFormat_ = vk::SurfaceFormatKHR() ) VULKAN_HPP_NOEXCEPT + : surfaceFormat( surfaceFormat_ ) {} + vk::SurfaceFormat2KHR & operator=( vk::SurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceFormat2KHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceFormat2KHR( rhs ) - {} + { + *this = rhs; + } SurfaceFormat2KHR& operator=( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SurfaceFormat2KHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63285,55 +57508,36 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SurfaceFormat2KHR::sType; + public: + const vk::StructureType sType = StructureType::eSurfaceFormat2KHR; + void* pNext = nullptr; + vk::SurfaceFormatKHR surfaceFormat; }; static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct SurfaceFullScreenExclusiveInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( vk::FullScreenExclusiveEXT fullScreenExclusive_ = vk::FullScreenExclusiveEXT::eDefault ) VULKAN_HPP_NOEXCEPT - : fullScreenExclusive( fullScreenExclusive_ ) - {} - - SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SurfaceFullScreenExclusiveInfoEXT& operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT; - void* pNext = nullptr; - vk::FullScreenExclusiveEXT fullScreenExclusive; - }; - static_assert( sizeof( SurfaceFullScreenExclusiveInfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct SurfaceFullScreenExclusiveInfoEXT : public layout::SurfaceFullScreenExclusiveInfoEXT + struct SurfaceFullScreenExclusiveInfoEXT { VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( vk::FullScreenExclusiveEXT fullScreenExclusive_ = vk::FullScreenExclusiveEXT::eDefault ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceFullScreenExclusiveInfoEXT( fullScreenExclusive_ ) + : fullScreenExclusive( fullScreenExclusive_ ) {} + vk::SurfaceFullScreenExclusiveInfoEXT & operator=( vk::SurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceFullScreenExclusiveInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceFullScreenExclusiveInfoEXT( rhs ) - {} + { + *this = rhs; + } SurfaceFullScreenExclusiveInfoEXT& operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SurfaceFullScreenExclusiveInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63371,8 +57575,10 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SurfaceFullScreenExclusiveInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT; + void* pNext = nullptr; + vk::FullScreenExclusiveEXT fullScreenExclusive; }; static_assert( sizeof( SurfaceFullScreenExclusiveInfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -63380,47 +57586,26 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct SurfaceFullScreenExclusiveWin32InfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = 0 ) VULKAN_HPP_NOEXCEPT - : hmonitor( hmonitor_ ) - {} - - SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SurfaceFullScreenExclusiveWin32InfoEXT& operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT; - const void* pNext = nullptr; - HMONITOR hmonitor; - }; - static_assert( sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveWin32InfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct SurfaceFullScreenExclusiveWin32InfoEXT : public layout::SurfaceFullScreenExclusiveWin32InfoEXT + struct SurfaceFullScreenExclusiveWin32InfoEXT { VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceFullScreenExclusiveWin32InfoEXT( hmonitor_ ) + : hmonitor( hmonitor_ ) {} + vk::SurfaceFullScreenExclusiveWin32InfoEXT & operator=( vk::SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceFullScreenExclusiveWin32InfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceFullScreenExclusiveWin32InfoEXT( rhs ) - {} + { + *this = rhs; + } SurfaceFullScreenExclusiveWin32InfoEXT& operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SurfaceFullScreenExclusiveWin32InfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63458,54 +57643,35 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SurfaceFullScreenExclusiveWin32InfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT; + const void* pNext = nullptr; + HMONITOR hmonitor; }; static_assert( sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveWin32InfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct SurfaceProtectedCapabilitiesKHR - { - protected: - VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( vk::Bool32 supportsProtected_ = 0 ) VULKAN_HPP_NOEXCEPT - : supportsProtected( supportsProtected_ ) - {} - - SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SurfaceProtectedCapabilitiesKHR& operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR; - const void* pNext = nullptr; - vk::Bool32 supportsProtected; - }; - static_assert( sizeof( SurfaceProtectedCapabilitiesKHR ) == sizeof( VkSurfaceProtectedCapabilitiesKHR ), "layout struct and wrapper have different size!" ); - } - - struct SurfaceProtectedCapabilitiesKHR : public layout::SurfaceProtectedCapabilitiesKHR + struct SurfaceProtectedCapabilitiesKHR { VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( vk::Bool32 supportsProtected_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceProtectedCapabilitiesKHR( supportsProtected_ ) + : supportsProtected( supportsProtected_ ) {} + vk::SurfaceProtectedCapabilitiesKHR & operator=( vk::SurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SurfaceProtectedCapabilitiesKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SurfaceProtectedCapabilitiesKHR( rhs ) - {} + { + *this = rhs; + } SurfaceProtectedCapabilitiesKHR& operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SurfaceProtectedCapabilitiesKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63543,53 +57709,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SurfaceProtectedCapabilitiesKHR::sType; + public: + const vk::StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR; + const void* pNext = nullptr; + vk::Bool32 supportsProtected; }; static_assert( sizeof( SurfaceProtectedCapabilitiesKHR ) == sizeof( VkSurfaceProtectedCapabilitiesKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SwapchainCounterCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( vk::SurfaceCounterFlagsEXT surfaceCounters_ = vk::SurfaceCounterFlagsEXT() ) VULKAN_HPP_NOEXCEPT - : surfaceCounters( surfaceCounters_ ) - {} - - SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT; - const void* pNext = nullptr; - vk::SurfaceCounterFlagsEXT surfaceCounters; - }; - static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct SwapchainCounterCreateInfoEXT : public layout::SwapchainCounterCreateInfoEXT + struct SwapchainCounterCreateInfoEXT { VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( vk::SurfaceCounterFlagsEXT surfaceCounters_ = vk::SurfaceCounterFlagsEXT() ) VULKAN_HPP_NOEXCEPT - : layout::SwapchainCounterCreateInfoEXT( surfaceCounters_ ) + : surfaceCounters( surfaceCounters_ ) {} + vk::SwapchainCounterCreateInfoEXT & operator=( vk::SwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SwapchainCounterCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SwapchainCounterCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SwapchainCounterCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63627,86 +57774,15 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SwapchainCounterCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT; + const void* pNext = nullptr; + vk::SurfaceCounterFlagsEXT surfaceCounters; }; static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SwapchainCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( vk::SwapchainCreateFlagsKHR flags_ = vk::SwapchainCreateFlagsKHR(), - vk::SurfaceKHR surface_ = vk::SurfaceKHR(), - uint32_t minImageCount_ = 0, - vk::Format imageFormat_ = vk::Format::eUndefined, - vk::ColorSpaceKHR imageColorSpace_ = vk::ColorSpaceKHR::eSrgbNonlinear, - vk::Extent2D imageExtent_ = vk::Extent2D(), - uint32_t imageArrayLayers_ = 0, - vk::ImageUsageFlags imageUsage_ = vk::ImageUsageFlags(), - vk::SharingMode imageSharingMode_ = vk::SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = 0, - const uint32_t* pQueueFamilyIndices_ = nullptr, - vk::SurfaceTransformFlagBitsKHR preTransform_ = vk::SurfaceTransformFlagBitsKHR::eIdentity, - vk::CompositeAlphaFlagBitsKHR compositeAlpha_ = vk::CompositeAlphaFlagBitsKHR::eOpaque, - vk::PresentModeKHR presentMode_ = vk::PresentModeKHR::eImmediate, - vk::Bool32 clipped_ = 0, - vk::SwapchainKHR oldSwapchain_ = vk::SwapchainKHR() ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , surface( surface_ ) - , minImageCount( minImageCount_ ) - , imageFormat( imageFormat_ ) - , imageColorSpace( imageColorSpace_ ) - , imageExtent( imageExtent_ ) - , imageArrayLayers( imageArrayLayers_ ) - , imageUsage( imageUsage_ ) - , imageSharingMode( imageSharingMode_ ) - , queueFamilyIndexCount( queueFamilyIndexCount_ ) - , pQueueFamilyIndices( pQueueFamilyIndices_ ) - , preTransform( preTransform_ ) - , compositeAlpha( compositeAlpha_ ) - , presentMode( presentMode_ ) - , clipped( clipped_ ) - , oldSwapchain( oldSwapchain_ ) - {} - - SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSwapchainCreateInfoKHR; - const void* pNext = nullptr; - vk::SwapchainCreateFlagsKHR flags; - vk::SurfaceKHR surface; - uint32_t minImageCount; - vk::Format imageFormat; - vk::ColorSpaceKHR imageColorSpace; - vk::Extent2D imageExtent; - uint32_t imageArrayLayers; - vk::ImageUsageFlags imageUsage; - vk::SharingMode imageSharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - vk::SurfaceTransformFlagBitsKHR preTransform; - vk::CompositeAlphaFlagBitsKHR compositeAlpha; - vk::PresentModeKHR presentMode; - vk::Bool32 clipped; - vk::SwapchainKHR oldSwapchain; - }; - static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct SwapchainCreateInfoKHR : public layout::SwapchainCreateInfoKHR + struct SwapchainCreateInfoKHR { VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( vk::SwapchainCreateFlagsKHR flags_ = vk::SwapchainCreateFlagsKHR(), vk::SurfaceKHR surface_ = vk::SurfaceKHR(), @@ -63724,16 +57800,38 @@ namespace VULKAN_HPP_NAMESPACE vk::PresentModeKHR presentMode_ = vk::PresentModeKHR::eImmediate, vk::Bool32 clipped_ = 0, vk::SwapchainKHR oldSwapchain_ = vk::SwapchainKHR() ) VULKAN_HPP_NOEXCEPT - : layout::SwapchainCreateInfoKHR( flags_, surface_, minImageCount_, imageFormat_, imageColorSpace_, imageExtent_, imageArrayLayers_, imageUsage_, imageSharingMode_, queueFamilyIndexCount_, pQueueFamilyIndices_, preTransform_, compositeAlpha_, presentMode_, clipped_, oldSwapchain_ ) + : flags( flags_ ) + , surface( surface_ ) + , minImageCount( minImageCount_ ) + , imageFormat( imageFormat_ ) + , imageColorSpace( imageColorSpace_ ) + , imageExtent( imageExtent_ ) + , imageArrayLayers( imageArrayLayers_ ) + , imageUsage( imageUsage_ ) + , imageSharingMode( imageSharingMode_ ) + , queueFamilyIndexCount( queueFamilyIndexCount_ ) + , pQueueFamilyIndices( pQueueFamilyIndices_ ) + , preTransform( preTransform_ ) + , compositeAlpha( compositeAlpha_ ) + , presentMode( presentMode_ ) + , clipped( clipped_ ) + , oldSwapchain( oldSwapchain_ ) {} + vk::SwapchainCreateInfoKHR & operator=( vk::SwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SwapchainCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SwapchainCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SwapchainCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63876,53 +57974,49 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SwapchainCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eSwapchainCreateInfoKHR; + const void* pNext = nullptr; + vk::SwapchainCreateFlagsKHR flags; + vk::SurfaceKHR surface; + uint32_t minImageCount; + vk::Format imageFormat; + vk::ColorSpaceKHR imageColorSpace; + vk::Extent2D imageExtent; + uint32_t imageArrayLayers; + vk::ImageUsageFlags imageUsage; + vk::SharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + vk::SurfaceTransformFlagBitsKHR preTransform; + vk::CompositeAlphaFlagBitsKHR compositeAlpha; + vk::PresentModeKHR presentMode; + vk::Bool32 clipped; + vk::SwapchainKHR oldSwapchain; }; static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct SwapchainDisplayNativeHdrCreateInfoAMD - { - protected: - VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( vk::Bool32 localDimmingEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : localDimmingEnable( localDimmingEnable_ ) - {} - - SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - SwapchainDisplayNativeHdrCreateInfoAMD& operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD; - const void* pNext = nullptr; - vk::Bool32 localDimmingEnable; - }; - static_assert( sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) == sizeof( VkSwapchainDisplayNativeHdrCreateInfoAMD ), "layout struct and wrapper have different size!" ); - } - - struct SwapchainDisplayNativeHdrCreateInfoAMD : public layout::SwapchainDisplayNativeHdrCreateInfoAMD + struct SwapchainDisplayNativeHdrCreateInfoAMD { VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( vk::Bool32 localDimmingEnable_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::SwapchainDisplayNativeHdrCreateInfoAMD( localDimmingEnable_ ) + : localDimmingEnable( localDimmingEnable_ ) {} + vk::SwapchainDisplayNativeHdrCreateInfoAMD & operator=( vk::SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::SwapchainDisplayNativeHdrCreateInfoAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::SwapchainDisplayNativeHdrCreateInfoAMD( rhs ) - {} + { + *this = rhs; + } SwapchainDisplayNativeHdrCreateInfoAMD& operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::SwapchainDisplayNativeHdrCreateInfoAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -63960,52 +58054,34 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::SwapchainDisplayNativeHdrCreateInfoAMD::sType; + public: + const vk::StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD; + const void* pNext = nullptr; + vk::Bool32 localDimmingEnable; }; static_assert( sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) == sizeof( VkSwapchainDisplayNativeHdrCreateInfoAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout + struct TextureLODGatherFormatPropertiesAMD { - struct TextureLODGatherFormatPropertiesAMD - { - protected: - TextureLODGatherFormatPropertiesAMD() VULKAN_HPP_NOEXCEPT - {} - - TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - TextureLODGatherFormatPropertiesAMD& operator=( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD; - void* pNext = nullptr; - vk::Bool32 supportsTextureGatherLODBiasAMD; - }; - static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "layout struct and wrapper have different size!" ); - } - - struct TextureLODGatherFormatPropertiesAMD : public layout::TextureLODGatherFormatPropertiesAMD - { - TextureLODGatherFormatPropertiesAMD() VULKAN_HPP_NOEXCEPT - : layout::TextureLODGatherFormatPropertiesAMD() + TextureLODGatherFormatPropertiesAMD( vk::Bool32 supportsTextureGatherLODBiasAMD_ = 0 ) VULKAN_HPP_NOEXCEPT + : supportsTextureGatherLODBiasAMD( supportsTextureGatherLODBiasAMD_ ) {} + vk::TextureLODGatherFormatPropertiesAMD & operator=( vk::TextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::TextureLODGatherFormatPropertiesAMD ) - sizeof( vk::StructureType ) ); + return *this; + } + TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::TextureLODGatherFormatPropertiesAMD( rhs ) - {} + { + *this = rhs; + } TextureLODGatherFormatPropertiesAMD& operator=( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::TextureLODGatherFormatPropertiesAMD::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64031,65 +58107,40 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::TextureLODGatherFormatPropertiesAMD::sType; + public: + const vk::StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD; + void* pNext = nullptr; + vk::Bool32 supportsTextureGatherLODBiasAMD; }; static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct TimelineSemaphoreSubmitInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfoKHR( uint32_t waitSemaphoreValueCount_ = 0, - const uint64_t* pWaitSemaphoreValues_ = nullptr, - uint32_t signalSemaphoreValueCount_ = 0, - const uint64_t* pSignalSemaphoreValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : waitSemaphoreValueCount( waitSemaphoreValueCount_ ) - , pWaitSemaphoreValues( pWaitSemaphoreValues_ ) - , signalSemaphoreValueCount( signalSemaphoreValueCount_ ) - , pSignalSemaphoreValues( pSignalSemaphoreValues_ ) - {} - - TimelineSemaphoreSubmitInfoKHR( VkTimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - TimelineSemaphoreSubmitInfoKHR& operator=( VkTimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eTimelineSemaphoreSubmitInfoKHR; - const void* pNext = nullptr; - uint32_t waitSemaphoreValueCount; - const uint64_t* pWaitSemaphoreValues; - uint32_t signalSemaphoreValueCount; - const uint64_t* pSignalSemaphoreValues; - }; - static_assert( sizeof( TimelineSemaphoreSubmitInfoKHR ) == sizeof( VkTimelineSemaphoreSubmitInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct TimelineSemaphoreSubmitInfoKHR : public layout::TimelineSemaphoreSubmitInfoKHR + struct TimelineSemaphoreSubmitInfoKHR { VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfoKHR( uint32_t waitSemaphoreValueCount_ = 0, const uint64_t* pWaitSemaphoreValues_ = nullptr, uint32_t signalSemaphoreValueCount_ = 0, const uint64_t* pSignalSemaphoreValues_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::TimelineSemaphoreSubmitInfoKHR( waitSemaphoreValueCount_, pWaitSemaphoreValues_, signalSemaphoreValueCount_, pSignalSemaphoreValues_ ) + : waitSemaphoreValueCount( waitSemaphoreValueCount_ ) + , pWaitSemaphoreValues( pWaitSemaphoreValues_ ) + , signalSemaphoreValueCount( signalSemaphoreValueCount_ ) + , pSignalSemaphoreValues( pSignalSemaphoreValues_ ) {} + vk::TimelineSemaphoreSubmitInfoKHR & operator=( vk::TimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::TimelineSemaphoreSubmitInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + TimelineSemaphoreSubmitInfoKHR( VkTimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::TimelineSemaphoreSubmitInfoKHR( rhs ) - {} + { + *this = rhs; + } TimelineSemaphoreSubmitInfoKHR& operator=( VkTimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::TimelineSemaphoreSubmitInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64148,61 +58199,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::TimelineSemaphoreSubmitInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eTimelineSemaphoreSubmitInfoKHR; + const void* pNext = nullptr; + uint32_t waitSemaphoreValueCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValueCount; + const uint64_t* pSignalSemaphoreValues; }; static_assert( sizeof( TimelineSemaphoreSubmitInfoKHR ) == sizeof( VkTimelineSemaphoreSubmitInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ValidationCacheCreateInfoEXT - { - protected: - VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( vk::ValidationCacheCreateFlagsEXT flags_ = vk::ValidationCacheCreateFlagsEXT(), - size_t initialDataSize_ = 0, - const void* pInitialData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , initialDataSize( initialDataSize_ ) - , pInitialData( pInitialData_ ) - {} - - ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eValidationCacheCreateInfoEXT; - const void* pNext = nullptr; - vk::ValidationCacheCreateFlagsEXT flags; - size_t initialDataSize; - const void* pInitialData; - }; - static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "layout struct and wrapper have different size!" ); - } - - struct ValidationCacheCreateInfoEXT : public layout::ValidationCacheCreateInfoEXT + struct ValidationCacheCreateInfoEXT { VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( vk::ValidationCacheCreateFlagsEXT flags_ = vk::ValidationCacheCreateFlagsEXT(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ValidationCacheCreateInfoEXT( flags_, initialDataSize_, pInitialData_ ) + : flags( flags_ ) + , initialDataSize( initialDataSize_ ) + , pInitialData( pInitialData_ ) {} + vk::ValidationCacheCreateInfoEXT & operator=( vk::ValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ValidationCacheCreateInfoEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ValidationCacheCreateInfoEXT( rhs ) - {} + { + *this = rhs; + } ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ValidationCacheCreateInfoEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64254,65 +58285,42 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ValidationCacheCreateInfoEXT::sType; + public: + const vk::StructureType sType = StructureType::eValidationCacheCreateInfoEXT; + const void* pNext = nullptr; + vk::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::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ValidationFeaturesEXT - { - protected: - VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = 0, - const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = nullptr, - uint32_t disabledValidationFeatureCount_ = 0, - const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures_ = nullptr ) VULKAN_HPP_NOEXCEPT - : enabledValidationFeatureCount( enabledValidationFeatureCount_ ) - , pEnabledValidationFeatures( pEnabledValidationFeatures_ ) - , disabledValidationFeatureCount( disabledValidationFeatureCount_ ) - , pDisabledValidationFeatures( pDisabledValidationFeatures_ ) - {} - - ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ValidationFeaturesEXT& operator=( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eValidationFeaturesEXT; - const void* pNext = nullptr; - uint32_t enabledValidationFeatureCount; - const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures; - uint32_t disabledValidationFeatureCount; - const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures; - }; - static_assert( sizeof( ValidationFeaturesEXT ) == sizeof( VkValidationFeaturesEXT ), "layout struct and wrapper have different size!" ); - } - - struct ValidationFeaturesEXT : public layout::ValidationFeaturesEXT + struct ValidationFeaturesEXT { VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = 0, const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures_ = nullptr, uint32_t disabledValidationFeatureCount_ = 0, const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ValidationFeaturesEXT( enabledValidationFeatureCount_, pEnabledValidationFeatures_, disabledValidationFeatureCount_, pDisabledValidationFeatures_ ) + : enabledValidationFeatureCount( enabledValidationFeatureCount_ ) + , pEnabledValidationFeatures( pEnabledValidationFeatures_ ) + , disabledValidationFeatureCount( disabledValidationFeatureCount_ ) + , pDisabledValidationFeatures( pDisabledValidationFeatures_ ) {} + vk::ValidationFeaturesEXT & operator=( vk::ValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ValidationFeaturesEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ValidationFeaturesEXT( rhs ) - {} + { + *this = rhs; + } ValidationFeaturesEXT& operator=( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ValidationFeaturesEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64371,57 +58379,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ValidationFeaturesEXT::sType; + public: + const vk::StructureType sType = StructureType::eValidationFeaturesEXT; + const void* pNext = nullptr; + uint32_t enabledValidationFeatureCount; + const vk::ValidationFeatureEnableEXT* pEnabledValidationFeatures; + uint32_t disabledValidationFeatureCount; + const vk::ValidationFeatureDisableEXT* pDisabledValidationFeatures; }; static_assert( sizeof( ValidationFeaturesEXT ) == sizeof( VkValidationFeaturesEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct ValidationFlagsEXT - { - protected: - VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, - const vk::ValidationCheckEXT* pDisabledValidationChecks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : disabledValidationCheckCount( disabledValidationCheckCount_ ) - , pDisabledValidationChecks( pDisabledValidationChecks_ ) - {} - - ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eValidationFlagsEXT; - const void* pNext = nullptr; - uint32_t disabledValidationCheckCount; - const vk::ValidationCheckEXT* pDisabledValidationChecks; - }; - static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "layout struct and wrapper have different size!" ); - } - - struct ValidationFlagsEXT : public layout::ValidationFlagsEXT + struct ValidationFlagsEXT { VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, const vk::ValidationCheckEXT* pDisabledValidationChecks_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ValidationFlagsEXT( disabledValidationCheckCount_, pDisabledValidationChecks_ ) + : disabledValidationCheckCount( disabledValidationCheckCount_ ) + , pDisabledValidationChecks( pDisabledValidationChecks_ ) {} + vk::ValidationFlagsEXT & operator=( vk::ValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ValidationFlagsEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ValidationFlagsEXT( rhs ) - {} + { + *this = rhs; + } ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ValidationFlagsEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64466,59 +58456,39 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ValidationFlagsEXT::sType; + public: + const vk::StructureType sType = StructureType::eValidationFlagsEXT; + const void* pNext = nullptr; + uint32_t disabledValidationCheckCount; + const vk::ValidationCheckEXT* pDisabledValidationChecks; }; static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_VI_NN - namespace layout - { - struct ViSurfaceCreateInfoNN - { - protected: - VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( vk::ViSurfaceCreateFlagsNN flags_ = vk::ViSurfaceCreateFlagsNN(), - void* window_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , window( window_ ) - {} - - ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eViSurfaceCreateInfoNN; - const void* pNext = nullptr; - vk::ViSurfaceCreateFlagsNN flags; - void* window; - }; - static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "layout struct and wrapper have different size!" ); - } - - struct ViSurfaceCreateInfoNN : public layout::ViSurfaceCreateInfoNN + struct ViSurfaceCreateInfoNN { VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( vk::ViSurfaceCreateFlagsNN flags_ = vk::ViSurfaceCreateFlagsNN(), void* window_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::ViSurfaceCreateInfoNN( flags_, window_ ) + : flags( flags_ ) + , window( window_ ) {} + vk::ViSurfaceCreateInfoNN & operator=( vk::ViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::ViSurfaceCreateInfoNN ) - sizeof( vk::StructureType ) ); + return *this; + } + ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::ViSurfaceCreateInfoNN( rhs ) - {} + { + *this = rhs; + } ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::ViSurfaceCreateInfoNN::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64563,8 +58533,11 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::ViSurfaceCreateInfoNN::sType; + public: + const vk::StructureType sType = StructureType::eViSurfaceCreateInfoNN; + const void* pNext = nullptr; + vk::ViSurfaceCreateFlagsNN flags; + void* window; }; static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -64572,55 +58545,30 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WAYLAND_KHR - namespace layout - { - struct WaylandSurfaceCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( vk::WaylandSurfaceCreateFlagsKHR flags_ = vk::WaylandSurfaceCreateFlagsKHR(), - struct wl_display* display_ = nullptr, - struct wl_surface* surface_ = nullptr ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , display( display_ ) - , surface( surface_ ) - {} - - WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR; - const void* pNext = nullptr; - vk::WaylandSurfaceCreateFlagsKHR flags; - struct wl_display* display; - struct wl_surface* surface; - }; - static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct WaylandSurfaceCreateInfoKHR : public layout::WaylandSurfaceCreateInfoKHR + struct WaylandSurfaceCreateInfoKHR { VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( vk::WaylandSurfaceCreateFlagsKHR flags_ = vk::WaylandSurfaceCreateFlagsKHR(), struct wl_display* display_ = nullptr, struct wl_surface* surface_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::WaylandSurfaceCreateInfoKHR( flags_, display_, surface_ ) + : flags( flags_ ) + , display( display_ ) + , surface( surface_ ) {} + vk::WaylandSurfaceCreateInfoKHR & operator=( vk::WaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::WaylandSurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::WaylandSurfaceCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::WaylandSurfaceCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64672,8 +58620,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::WaylandSurfaceCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR; + const void* pNext = nullptr; + vk::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::value, "struct wrapper is not a standard layout!" ); @@ -64681,53 +58633,7 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct Win32KeyedMutexAcquireReleaseInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0, - const vk::DeviceMemory* pAcquireSyncs_ = nullptr, - const uint64_t* pAcquireKeys_ = nullptr, - const uint32_t* pAcquireTimeouts_ = nullptr, - uint32_t releaseCount_ = 0, - const vk::DeviceMemory* pReleaseSyncs_ = nullptr, - const uint64_t* pReleaseKeys_ = nullptr ) VULKAN_HPP_NOEXCEPT - : acquireCount( acquireCount_ ) - , pAcquireSyncs( pAcquireSyncs_ ) - , pAcquireKeys( pAcquireKeys_ ) - , pAcquireTimeouts( pAcquireTimeouts_ ) - , releaseCount( releaseCount_ ) - , pReleaseSyncs( pReleaseSyncs_ ) - , pReleaseKeys( pReleaseKeys_ ) - {} - - Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; - const void* pNext = nullptr; - uint32_t acquireCount; - const vk::DeviceMemory* pAcquireSyncs; - const uint64_t* pAcquireKeys; - const uint32_t* pAcquireTimeouts; - uint32_t releaseCount; - const vk::DeviceMemory* pReleaseSyncs; - const uint64_t* pReleaseKeys; - }; - static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct Win32KeyedMutexAcquireReleaseInfoKHR : public layout::Win32KeyedMutexAcquireReleaseInfoKHR + struct Win32KeyedMutexAcquireReleaseInfoKHR { VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0, const vk::DeviceMemory* pAcquireSyncs_ = nullptr, @@ -64736,16 +58642,29 @@ namespace VULKAN_HPP_NAMESPACE uint32_t releaseCount_ = 0, const vk::DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::Win32KeyedMutexAcquireReleaseInfoKHR( acquireCount_, pAcquireSyncs_, pAcquireKeys_, pAcquireTimeouts_, releaseCount_, pReleaseSyncs_, pReleaseKeys_ ) + : acquireCount( acquireCount_ ) + , pAcquireSyncs( pAcquireSyncs_ ) + , pAcquireKeys( pAcquireKeys_ ) + , pAcquireTimeouts( pAcquireTimeouts_ ) + , releaseCount( releaseCount_ ) + , pReleaseSyncs( pReleaseSyncs_ ) + , pReleaseKeys( pReleaseKeys_ ) {} + vk::Win32KeyedMutexAcquireReleaseInfoKHR & operator=( vk::Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::Win32KeyedMutexAcquireReleaseInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::Win32KeyedMutexAcquireReleaseInfoKHR( rhs ) - {} + { + *this = rhs; + } Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::Win32KeyedMutexAcquireReleaseInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64825,8 +58744,16 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::Win32KeyedMutexAcquireReleaseInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; + const void* pNext = nullptr; + uint32_t acquireCount; + const vk::DeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeouts; + uint32_t releaseCount; + const vk::DeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; }; static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -64834,53 +58761,7 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct Win32KeyedMutexAcquireReleaseInfoNV - { - protected: - VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0, - const vk::DeviceMemory* pAcquireSyncs_ = nullptr, - const uint64_t* pAcquireKeys_ = nullptr, - const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr, - uint32_t releaseCount_ = 0, - const vk::DeviceMemory* pReleaseSyncs_ = nullptr, - const uint64_t* pReleaseKeys_ = nullptr ) VULKAN_HPP_NOEXCEPT - : acquireCount( acquireCount_ ) - , pAcquireSyncs( pAcquireSyncs_ ) - , pAcquireKeys( pAcquireKeys_ ) - , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ ) - , releaseCount( releaseCount_ ) - , pReleaseSyncs( pReleaseSyncs_ ) - , pReleaseKeys( pReleaseKeys_ ) - {} - - Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; - const void* pNext = nullptr; - uint32_t acquireCount; - const vk::DeviceMemory* pAcquireSyncs; - const uint64_t* pAcquireKeys; - const uint32_t* pAcquireTimeoutMilliseconds; - uint32_t releaseCount; - const vk::DeviceMemory* pReleaseSyncs; - const uint64_t* pReleaseKeys; - }; - static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "layout struct and wrapper have different size!" ); - } - - struct Win32KeyedMutexAcquireReleaseInfoNV : public layout::Win32KeyedMutexAcquireReleaseInfoNV + struct Win32KeyedMutexAcquireReleaseInfoNV { VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0, const vk::DeviceMemory* pAcquireSyncs_ = nullptr, @@ -64889,16 +58770,29 @@ namespace VULKAN_HPP_NAMESPACE uint32_t releaseCount_ = 0, const vk::DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::Win32KeyedMutexAcquireReleaseInfoNV( acquireCount_, pAcquireSyncs_, pAcquireKeys_, pAcquireTimeoutMilliseconds_, releaseCount_, pReleaseSyncs_, pReleaseKeys_ ) + : acquireCount( acquireCount_ ) + , pAcquireSyncs( pAcquireSyncs_ ) + , pAcquireKeys( pAcquireKeys_ ) + , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ ) + , releaseCount( releaseCount_ ) + , pReleaseSyncs( pReleaseSyncs_ ) + , pReleaseKeys( pReleaseKeys_ ) {} + vk::Win32KeyedMutexAcquireReleaseInfoNV & operator=( vk::Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::Win32KeyedMutexAcquireReleaseInfoNV ) - sizeof( vk::StructureType ) ); + return *this; + } + Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::Win32KeyedMutexAcquireReleaseInfoNV( rhs ) - {} + { + *this = rhs; + } Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::Win32KeyedMutexAcquireReleaseInfoNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -64978,8 +58872,16 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::Win32KeyedMutexAcquireReleaseInfoNV::sType; + public: + const vk::StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; + const void* pNext = nullptr; + uint32_t acquireCount; + const vk::DeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeoutMilliseconds; + uint32_t releaseCount; + const vk::DeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; }; static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -64987,55 +58889,30 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_WIN32_KHR - namespace layout - { - struct Win32SurfaceCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( vk::Win32SurfaceCreateFlagsKHR flags_ = vk::Win32SurfaceCreateFlagsKHR(), - HINSTANCE hinstance_ = 0, - HWND hwnd_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , hinstance( hinstance_ ) - , hwnd( hwnd_ ) - {} - - Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR; - const void* pNext = nullptr; - vk::Win32SurfaceCreateFlagsKHR flags; - HINSTANCE hinstance; - HWND hwnd; - }; - static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct Win32SurfaceCreateInfoKHR : public layout::Win32SurfaceCreateInfoKHR + struct Win32SurfaceCreateInfoKHR { VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( vk::Win32SurfaceCreateFlagsKHR flags_ = vk::Win32SurfaceCreateFlagsKHR(), HINSTANCE hinstance_ = 0, HWND hwnd_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::Win32SurfaceCreateInfoKHR( flags_, hinstance_, hwnd_ ) + : flags( flags_ ) + , hinstance( hinstance_ ) + , hwnd( hwnd_ ) {} + vk::Win32SurfaceCreateInfoKHR & operator=( vk::Win32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::Win32SurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::Win32SurfaceCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::Win32SurfaceCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -65087,63 +58964,18 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::Win32SurfaceCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR; + const void* pNext = nullptr; + vk::Win32SurfaceCreateFlagsKHR flags; + HINSTANCE hinstance; + HWND hwnd; }; static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ - namespace layout - { - struct WriteDescriptorSet - { - protected: - VULKAN_HPP_CONSTEXPR WriteDescriptorSet( vk::DescriptorSet dstSet_ = vk::DescriptorSet(), - uint32_t dstBinding_ = 0, - uint32_t dstArrayElement_ = 0, - uint32_t descriptorCount_ = 0, - vk::DescriptorType descriptorType_ = vk::DescriptorType::eSampler, - const vk::DescriptorImageInfo* pImageInfo_ = nullptr, - const vk::DescriptorBufferInfo* pBufferInfo_ = nullptr, - const vk::BufferView* pTexelBufferView_ = nullptr ) VULKAN_HPP_NOEXCEPT - : dstSet( dstSet_ ) - , dstBinding( dstBinding_ ) - , dstArrayElement( dstArrayElement_ ) - , descriptorCount( descriptorCount_ ) - , descriptorType( descriptorType_ ) - , pImageInfo( pImageInfo_ ) - , pBufferInfo( pBufferInfo_ ) - , pTexelBufferView( pTexelBufferView_ ) - {} - - WriteDescriptorSet( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eWriteDescriptorSet; - const void* pNext = nullptr; - vk::DescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - vk::DescriptorType descriptorType; - const vk::DescriptorImageInfo* pImageInfo; - const vk::DescriptorBufferInfo* pBufferInfo; - const vk::BufferView* pTexelBufferView; - }; - static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "layout struct and wrapper have different size!" ); - } - - struct WriteDescriptorSet : public layout::WriteDescriptorSet + struct WriteDescriptorSet { VULKAN_HPP_CONSTEXPR WriteDescriptorSet( vk::DescriptorSet dstSet_ = vk::DescriptorSet(), uint32_t dstBinding_ = 0, @@ -65153,16 +58985,30 @@ namespace VULKAN_HPP_NAMESPACE const vk::DescriptorImageInfo* pImageInfo_ = nullptr, const vk::DescriptorBufferInfo* pBufferInfo_ = nullptr, const vk::BufferView* pTexelBufferView_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::WriteDescriptorSet( dstSet_, dstBinding_, dstArrayElement_, descriptorCount_, descriptorType_, pImageInfo_, pBufferInfo_, pTexelBufferView_ ) + : dstSet( dstSet_ ) + , dstBinding( dstBinding_ ) + , dstArrayElement( dstArrayElement_ ) + , descriptorCount( descriptorCount_ ) + , descriptorType( descriptorType_ ) + , pImageInfo( pImageInfo_ ) + , pBufferInfo( pBufferInfo_ ) + , pTexelBufferView( pTexelBufferView_ ) {} + vk::WriteDescriptorSet & operator=( vk::WriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::WriteDescriptorSet ) - sizeof( vk::StructureType ) ); + return *this; + } + WriteDescriptorSet( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::WriteDescriptorSet( rhs ) - {} + { + *this = rhs; + } WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::WriteDescriptorSet::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -65249,57 +59095,43 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::WriteDescriptorSet::sType; + public: + const vk::StructureType sType = StructureType::eWriteDescriptorSet; + const void* pNext = nullptr; + vk::DescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + vk::DescriptorType descriptorType; + const vk::DescriptorImageInfo* pImageInfo; + const vk::DescriptorBufferInfo* pBufferInfo; + const vk::BufferView* pTexelBufferView; }; static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct WriteDescriptorSetAccelerationStructureNV - { - protected: - VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0, - const vk::AccelerationStructureNV* pAccelerationStructures_ = nullptr ) VULKAN_HPP_NOEXCEPT - : accelerationStructureCount( accelerationStructureCount_ ) - , pAccelerationStructures( pAccelerationStructures_ ) - {} - - WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV; - const void* pNext = nullptr; - uint32_t accelerationStructureCount; - const vk::AccelerationStructureNV* pAccelerationStructures; - }; - static_assert( sizeof( WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), "layout struct and wrapper have different size!" ); - } - - struct WriteDescriptorSetAccelerationStructureNV : public layout::WriteDescriptorSetAccelerationStructureNV + struct WriteDescriptorSetAccelerationStructureNV { VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0, const vk::AccelerationStructureNV* pAccelerationStructures_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::WriteDescriptorSetAccelerationStructureNV( accelerationStructureCount_, pAccelerationStructures_ ) + : accelerationStructureCount( accelerationStructureCount_ ) + , pAccelerationStructures( pAccelerationStructures_ ) {} + vk::WriteDescriptorSetAccelerationStructureNV & operator=( vk::WriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::WriteDescriptorSetAccelerationStructureNV ) - sizeof( vk::StructureType ) ); + return *this; + } + WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::WriteDescriptorSetAccelerationStructureNV( rhs ) - {} + { + *this = rhs; + } WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::WriteDescriptorSetAccelerationStructureNV::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -65344,57 +59176,37 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::WriteDescriptorSetAccelerationStructureNV::sType; + public: + const vk::StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV; + const void* pNext = nullptr; + uint32_t accelerationStructureCount; + const vk::AccelerationStructureNV* pAccelerationStructures; }; static_assert( sizeof( WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); - namespace layout - { - struct WriteDescriptorSetInlineUniformBlockEXT - { - protected: - VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0, - const void* pData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : dataSize( dataSize_ ) - , pData( pData_ ) - {} - - WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT; - const void* pNext = nullptr; - uint32_t dataSize; - const void* pData; - }; - static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "layout struct and wrapper have different size!" ); - } - - struct WriteDescriptorSetInlineUniformBlockEXT : public layout::WriteDescriptorSetInlineUniformBlockEXT + struct WriteDescriptorSetInlineUniformBlockEXT { VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlockEXT( uint32_t dataSize_ = 0, const void* pData_ = nullptr ) VULKAN_HPP_NOEXCEPT - : layout::WriteDescriptorSetInlineUniformBlockEXT( dataSize_, pData_ ) + : dataSize( dataSize_ ) + , pData( pData_ ) {} + vk::WriteDescriptorSetInlineUniformBlockEXT & operator=( vk::WriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::WriteDescriptorSetInlineUniformBlockEXT ) - sizeof( vk::StructureType ) ); + return *this; + } + WriteDescriptorSetInlineUniformBlockEXT( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::WriteDescriptorSetInlineUniformBlockEXT( rhs ) - {} + { + *this = rhs; + } WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::WriteDescriptorSetInlineUniformBlockEXT::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -65439,63 +59251,41 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::WriteDescriptorSetInlineUniformBlockEXT::sType; + public: + const vk::StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlockEXT; + const void* pNext = nullptr; + uint32_t dataSize; + const void* pData; }; static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); #ifdef VK_USE_PLATFORM_XCB_KHR - namespace layout - { - struct XcbSurfaceCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( vk::XcbSurfaceCreateFlagsKHR flags_ = vk::XcbSurfaceCreateFlagsKHR(), - xcb_connection_t* connection_ = nullptr, - xcb_window_t window_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , connection( connection_ ) - , window( window_ ) - {} - - XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR; - const void* pNext = nullptr; - vk::XcbSurfaceCreateFlagsKHR flags; - xcb_connection_t* connection; - xcb_window_t window; - }; - static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct XcbSurfaceCreateInfoKHR : public layout::XcbSurfaceCreateInfoKHR + struct XcbSurfaceCreateInfoKHR { VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( vk::XcbSurfaceCreateFlagsKHR flags_ = vk::XcbSurfaceCreateFlagsKHR(), xcb_connection_t* connection_ = nullptr, xcb_window_t window_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::XcbSurfaceCreateInfoKHR( flags_, connection_, window_ ) + : flags( flags_ ) + , connection( connection_ ) + , window( window_ ) {} + vk::XcbSurfaceCreateInfoKHR & operator=( vk::XcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::XcbSurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::XcbSurfaceCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::XcbSurfaceCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -65547,8 +59337,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::XcbSurfaceCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR; + const void* pNext = nullptr; + vk::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::value, "struct wrapper is not a standard layout!" ); @@ -65556,55 +59350,30 @@ namespace VULKAN_HPP_NAMESPACE #ifdef VK_USE_PLATFORM_XLIB_KHR - namespace layout - { - struct XlibSurfaceCreateInfoKHR - { - protected: - VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( vk::XlibSurfaceCreateFlagsKHR flags_ = vk::XlibSurfaceCreateFlagsKHR(), - Display* dpy_ = nullptr, - Window window_ = 0 ) VULKAN_HPP_NOEXCEPT - : flags( flags_ ) - , dpy( dpy_ ) - , window( window_ ) - {} - - XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - } - - XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *reinterpret_cast(this) = rhs; - return *this; - } - - public: - vk::StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR; - const void* pNext = nullptr; - vk::XlibSurfaceCreateFlagsKHR flags; - Display* dpy; - Window window; - }; - static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "layout struct and wrapper have different size!" ); - } - - struct XlibSurfaceCreateInfoKHR : public layout::XlibSurfaceCreateInfoKHR + struct XlibSurfaceCreateInfoKHR { VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( vk::XlibSurfaceCreateFlagsKHR flags_ = vk::XlibSurfaceCreateFlagsKHR(), Display* dpy_ = nullptr, Window window_ = 0 ) VULKAN_HPP_NOEXCEPT - : layout::XlibSurfaceCreateInfoKHR( flags_, dpy_, window_ ) + : flags( flags_ ) + , dpy( dpy_ ) + , window( window_ ) {} + vk::XlibSurfaceCreateInfoKHR & operator=( vk::XlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + memcpy( &pNext, &rhs.pNext, sizeof( vk::XlibSurfaceCreateInfoKHR ) - sizeof( vk::StructureType ) ); + return *this; + } + XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : layout::XlibSurfaceCreateInfoKHR( rhs ) - {} + { + *this = rhs; + } XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - layout::XlibSurfaceCreateInfoKHR::operator=(rhs); + *this = *reinterpret_cast(&rhs); return *this; } @@ -65656,8 +59425,12 @@ namespace VULKAN_HPP_NAMESPACE return !operator==( rhs ); } - private: - using layout::XlibSurfaceCreateInfoKHR::sType; + public: + const vk::StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR; + const void* pNext = nullptr; + vk::XlibSurfaceCreateFlagsKHR flags; + Display* dpy; + Window window; }; static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" ); static_assert( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -67223,6 +60996,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + VULKAN_HPP_INLINE Result Device::acquireProfilingLockKHR( const vk::AcquireProfilingLockInfoKHR* pInfo, Dispatch const &d) const + { + return static_cast( d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast( pInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE ResultValueType::type Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const &d ) const + { + Result result = static_cast( d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast( &info ) ) ); + return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireProfilingLockKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const vk::CommandBufferAllocateInfo* pAllocateInfo, vk::CommandBuffer* pCommandBuffers, Dispatch const &d) const { @@ -70755,6 +64542,17 @@ namespace VULKAN_HPP_NAMESPACE Result result = static_cast( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast( &deviceEventInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ) ); return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerEventEXT" ); } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo, Optional allocator, Dispatch const &d ) const + { + vk::Fence fence; + Result result = static_cast( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast( &deviceEventInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ) ); + + ObjectDestroy deleter( *this, allocator, d ); + return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerEventEXTUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -70770,6 +64568,17 @@ namespace VULKAN_HPP_NAMESPACE Result result = static_cast( d.vkRegisterDisplayEventEXT( m_device, static_cast( display ), reinterpret_cast( &displayEventInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ) ); return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerDisplayEventEXT" ); } +#ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_INLINE typename ResultValueType>::type Device::registerDisplayEventEXTUnique( vk::DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional allocator, Dispatch const &d ) const + { + vk::Fence fence; + Result result = static_cast( d.vkRegisterDisplayEventEXT( m_device, static_cast( display ), reinterpret_cast( &displayEventInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ) ); + + ObjectDestroy deleter( *this, allocator, d ); + return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerDisplayEventEXTUnique", deleter ); + } +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -70826,6 +64635,20 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR(Dispatch const &d) const VULKAN_HPP_NOEXCEPT + { + d.vkReleaseProfilingLockKHR( m_device ); + } +#else + template + VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR(Dispatch const &d ) const VULKAN_HPP_NOEXCEPT + { + d.vkReleaseProfilingLockKHR( m_device ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE Result Device::resetCommandPool( vk::CommandPool commandPool, vk::CommandPoolResetFlags flags, Dispatch const &d) const @@ -72006,6 +65829,58 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + VULKAN_HPP_INLINE Result PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, uint32_t* pCounterCount, vk::PerformanceCounterKHR* pCounters, vk::PerformanceCounterDescriptionKHR* pCounterDescriptions, Dispatch const &d) const + { + return static_cast( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, pCounterCount, reinterpret_cast( pCounters ), reinterpret_cast( pCounterDescriptions ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, ArrayProxy counters, Dispatch const &d ) const + { + std::vector counterDescriptions; + uint32_t counterCount; + Result result; + do + { + result = static_cast( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, counters.size() , reinterpret_cast( counters.data() ), nullptr ) ); + if ( ( result == Result::eSuccess ) && counterCount ) + { + counterDescriptions.resize( counterCount ); + result = static_cast( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, counters.size() , reinterpret_cast( counters.data() ), reinterpret_cast( counterDescriptions.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( counterCount <= counterDescriptions.size() ); + counterDescriptions.resize( counterCount ); + } + return createResultValue( result, counterDescriptions, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); + } + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, ArrayProxy counters, Allocator const& vectorAllocator, Dispatch const &d ) const + { + std::vector counterDescriptions( vectorAllocator ); + uint32_t counterCount; + Result result; + do + { + result = static_cast( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, counters.size() , reinterpret_cast( counters.data() ), nullptr ) ); + if ( ( result == Result::eSuccess ) && counterCount ) + { + counterDescriptions.resize( counterCount ); + result = static_cast( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, counters.size() , reinterpret_cast( counters.data() ), reinterpret_cast( counterDescriptions.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + if ( result == Result::eSuccess ) + { + VULKAN_HPP_ASSERT( counterCount <= counterDescriptions.size() ); + counterDescriptions.resize( counterCount ); + } + return createResultValue( result, counterDescriptions, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModeProperties2KHR( vk::DisplayKHR display, uint32_t* pPropertyCount, vk::DisplayModeProperties2KHR* pProperties, Dispatch const &d) const { @@ -72996,6 +66871,21 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template + VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( const vk::QueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses, Dispatch const &d) const VULKAN_HPP_NOEXCEPT + { + d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( m_physicalDevice, reinterpret_cast( pPerformanceQueryCreateInfo ), pNumPasses ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const &d ) const VULKAN_HPP_NOEXCEPT + { + uint32_t numPasses; + d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( m_physicalDevice, reinterpret_cast( &performanceQueryCreateInfo ), &numPasses ); + return numPasses; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + template VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT { @@ -73057,7 +66947,16 @@ namespace VULKAN_HPP_NAMESPACE uint32_t queueFamilyPropertyCount; d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); queueFamilyProperties.resize( queueFamilyPropertyCount ); - d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + std::vector localVector( queueFamilyPropertyCount ); + for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ ) + { + localVector[i].pNext = queueFamilyProperties[i].template get().pNext; + } + d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( localVector.data() ) ); + for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ ) + { + queueFamilyProperties[i].template get() = localVector[i]; + } return queueFamilyProperties; } template @@ -73067,7 +66966,16 @@ namespace VULKAN_HPP_NAMESPACE uint32_t queueFamilyPropertyCount; d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); queueFamilyProperties.resize( queueFamilyPropertyCount ); - d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + std::vector localVector( queueFamilyPropertyCount ); + for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ ) + { + localVector[i].pNext = queueFamilyProperties[i].template get().pNext; + } + d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( localVector.data() ) ); + for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ ) + { + queueFamilyProperties[i].template get() = localVector[i]; + } return queueFamilyProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -73105,7 +67013,16 @@ namespace VULKAN_HPP_NAMESPACE uint32_t queueFamilyPropertyCount; d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); queueFamilyProperties.resize( queueFamilyPropertyCount ); - d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + std::vector localVector( queueFamilyPropertyCount ); + for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ ) + { + localVector[i].pNext = queueFamilyProperties[i].template get().pNext; + } + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( localVector.data() ) ); + for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ ) + { + queueFamilyProperties[i].template get() = localVector[i]; + } return queueFamilyProperties; } template @@ -73115,7 +67032,16 @@ namespace VULKAN_HPP_NAMESPACE uint32_t queueFamilyPropertyCount; d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); queueFamilyProperties.resize( queueFamilyPropertyCount ); - d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + std::vector localVector( queueFamilyPropertyCount ); + for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ ) + { + localVector[i].pNext = queueFamilyProperties[i].template get().pNext; + } + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( localVector.data() ) ); + for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ ) + { + queueFamilyProperties[i].template get() = localVector[i]; + } return queueFamilyProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -73857,6 +67783,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -73932,6 +67859,9 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -74031,6 +67961,7 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; + template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; @@ -74076,10 +68007,6 @@ namespace VULKAN_HPP_NAMESPACE template <> struct isStructureChainValid{ enum { value = true }; }; template <> struct isStructureChainValid{ enum { value = true }; }; -#if !defined(VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL) -# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1 -#endif - #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL class DynamicLoader { @@ -74095,7 +68022,7 @@ namespace VULKAN_HPP_NAMESPACE #elif defined(__APPLE__) m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL ); #elif defined(_WIN32) - m_library = LoadLibrary( "vulkan-1.dll" ); + m_library = LoadLibrary( TEXT( "vulkan-1.dll" ) ); #else assert( false && "unsupported platform" ); #endif @@ -74255,6 +68182,7 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0; + PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0; PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; PFN_vkAllocateMemory vkAllocateMemory = 0; @@ -74426,6 +68354,7 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0; + PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0; PFN_vkResetCommandPool vkResetCommandPool = 0; PFN_vkResetDescriptorPool vkResetDescriptorPool = 0; PFN_vkResetEvent vkResetEvent = 0; @@ -74501,6 +68430,7 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0; PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0; PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0; + PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0; PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0; PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0; PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0; @@ -74537,6 +68467,7 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0; PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0; PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0; + PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0; PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0; PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0; PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0; @@ -74630,8 +68561,9 @@ namespace VULKAN_HPP_NAMESPACE } } - void init( vk::Instance instance ) VULKAN_HPP_NOEXCEPT + void init( vk::Instance instanceCpp ) VULKAN_HPP_NOEXCEPT { + VkInstance instance = static_cast(instanceCpp); #ifdef VK_USE_PLATFORM_ANDROID_KHR vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) ); #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ @@ -74685,6 +68617,7 @@ namespace VULKAN_HPP_NAMESPACE vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) ); vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) ); vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) ); + vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) ); vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) ); vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) ); vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) ); @@ -74721,6 +68654,7 @@ namespace VULKAN_HPP_NAMESPACE vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) ); vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) ); vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) ); + vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) ); vkGetPhysicalDeviceQueueFamilyProperties = PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) ); vkGetPhysicalDeviceQueueFamilyProperties2 = PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) ); vkGetPhysicalDeviceQueueFamilyProperties2KHR = PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) ); @@ -74856,6 +68790,7 @@ namespace VULKAN_HPP_NAMESPACE vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) ); vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) ); vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkAcquirePerformanceConfigurationINTEL" ) ); + vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkAcquireProfilingLockKHR" ) ); vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) ); vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) ); vkAllocateMemory = PFN_vkAllocateMemory( vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) ); @@ -75027,6 +68962,7 @@ namespace VULKAN_HPP_NAMESPACE vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkReleasePerformanceConfigurationINTEL" ) ); + vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkReleaseProfilingLockKHR" ) ); vkResetCommandPool = PFN_vkResetCommandPool( vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) ); vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) ); vkResetEvent = PFN_vkResetEvent( vkGetInstanceProcAddr( instance, "vkResetEvent" ) ); @@ -75059,8 +68995,9 @@ namespace VULKAN_HPP_NAMESPACE vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) ); } - void init( vk::Device device ) VULKAN_HPP_NOEXCEPT + void init( vk::Device deviceCpp ) VULKAN_HPP_NOEXCEPT { + VkDevice device = static_cast(deviceCpp); vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) ); vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) ); vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) ); @@ -75163,6 +69100,7 @@ namespace VULKAN_HPP_NAMESPACE vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) ); vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) ); vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) ); + vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) ); vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) ); vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) ); vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) ); @@ -75334,6 +69272,7 @@ namespace VULKAN_HPP_NAMESPACE vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) ); + vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) ); vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) ); vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) ); vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) ); diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h index 5f7c485..246ae72 100644 --- a/include/vulkan/vulkan_core.h +++ b/include/vulkan/vulkan_core.h @@ -44,7 +44,7 @@ extern "C" { #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) // Version of this file -#define VK_HEADER_VERSION 127 +#define VK_HEADER_VERSION 128 #define VK_NULL_HANDLE 0 @@ -370,6 +370,13 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, + VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, + VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, + VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, @@ -951,6 +958,7 @@ typedef enum VkQueryType { VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, VK_QUERY_TYPE_TIMESTAMP = 2, VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, + VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000, VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, @@ -1691,10 +1699,11 @@ typedef enum VkPipelineCreateFlagBits { VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, - VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010, + VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010, VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020, VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040, VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080, + VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE, VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF @@ -5915,6 +5924,150 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( #endif +#define VK_KHR_performance_query 1 +#define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1 +#define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query" + +typedef enum VkPerformanceCounterUnitKHR { + VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0, + VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1, + VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2, + VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3, + VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4, + VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5, + VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6, + VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7, + VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8, + VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9, + VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10, + VK_PERFORMANCE_COUNTER_UNIT_BEGIN_RANGE_KHR = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR, + VK_PERFORMANCE_COUNTER_UNIT_END_RANGE_KHR = VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR, + VK_PERFORMANCE_COUNTER_UNIT_RANGE_SIZE_KHR = (VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR - VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR + 1), + VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterUnitKHR; + +typedef enum VkPerformanceCounterScopeKHR { + VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = 0, + VK_QUERY_SCOPE_RENDER_PASS_KHR = 1, + VK_QUERY_SCOPE_COMMAND_KHR = 2, + VK_PERFORMANCE_COUNTER_SCOPE_BEGIN_RANGE_KHR = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR, + VK_PERFORMANCE_COUNTER_SCOPE_END_RANGE_KHR = VK_QUERY_SCOPE_COMMAND_KHR, + VK_PERFORMANCE_COUNTER_SCOPE_RANGE_SIZE_KHR = (VK_QUERY_SCOPE_COMMAND_KHR - VK_QUERY_SCOPE_COMMAND_BUFFER_KHR + 1), + VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterScopeKHR; + +typedef enum VkPerformanceCounterStorageKHR { + VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0, + VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1, + VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2, + VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3, + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4, + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5, + VK_PERFORMANCE_COUNTER_STORAGE_BEGIN_RANGE_KHR = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR, + VK_PERFORMANCE_COUNTER_STORAGE_END_RANGE_KHR = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR, + VK_PERFORMANCE_COUNTER_STORAGE_RANGE_SIZE_KHR = (VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR - VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR + 1), + VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterStorageKHR; + +typedef enum VkPerformanceCounterDescriptionFlagBitsKHR { + VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = 0x00000001, + VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = 0x00000002, + VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterDescriptionFlagBitsKHR; +typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; + +typedef enum VkAcquireProfilingLockFlagBitsKHR { + VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAcquireProfilingLockFlagBitsKHR; +typedef VkFlags VkAcquireProfilingLockFlagsKHR; +typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 performanceCounterQueryPools; + VkBool32 performanceCounterMultipleQueryPools; +} VkPhysicalDevicePerformanceQueryFeaturesKHR; + +typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 allowCommandBufferQueryCopies; +} VkPhysicalDevicePerformanceQueryPropertiesKHR; + +typedef struct VkPerformanceCounterKHR { + VkStructureType sType; + const void* pNext; + VkPerformanceCounterUnitKHR unit; + VkPerformanceCounterScopeKHR scope; + VkPerformanceCounterStorageKHR storage; + uint8_t uuid[VK_UUID_SIZE]; +} VkPerformanceCounterKHR; + +typedef struct VkPerformanceCounterDescriptionKHR { + VkStructureType sType; + const void* pNext; + VkPerformanceCounterDescriptionFlagsKHR flags; + char name[VK_MAX_DESCRIPTION_SIZE]; + char category[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkPerformanceCounterDescriptionKHR; + +typedef struct VkQueryPoolPerformanceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + uint32_t counterIndexCount; + const uint32_t* pCounterIndices; +} VkQueryPoolPerformanceCreateInfoKHR; + +typedef union VkPerformanceCounterResultKHR { + int32_t int32; + int64_t int64; + uint32_t uint32; + uint64_t uint64; + float float32; + double float64; +} VkPerformanceCounterResultKHR; + +typedef struct VkAcquireProfilingLockInfoKHR { + VkStructureType sType; + const void* pNext; + VkAcquireProfilingLockFlagsKHR flags; + uint64_t timeout; +} VkAcquireProfilingLockInfoKHR; + +typedef struct VkPerformanceQuerySubmitInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t counterPassIndex; +} VkPerformanceQuerySubmitInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pCounterCount, + VkPerformanceCounterKHR* pCounters, + VkPerformanceCounterDescriptionKHR* pCounterDescriptions); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + VkPhysicalDevice physicalDevice, + const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, + uint32_t* pNumPasses); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR( + VkDevice device, + const VkAcquireProfilingLockInfoKHR* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR( + VkDevice device); +#endif + + #define VK_KHR_maintenance2 1 #define VK_KHR_MAINTENANCE2_SPEC_VERSION 1 #define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2" @@ -7178,7 +7331,7 @@ typedef struct VkValidationFlagsEXT { #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr" typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT { VkStructureType sType; - const void* pNext; + void* pNext; VkBool32 textureCompressionASTC_HDR; } VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; diff --git a/registry/validusage.json b/registry/validusage.json index f9331ef..4a18fdc 100644 --- a/registry/validusage.json +++ b/registry/validusage.json @@ -1,9 +1,9 @@ { "version info": { "schema version": 2, - "api version": "1.1.127", - "comment": "from git branch: github-master commit: fa497b29d87078e1fee7372e369e9a1a788d6358", - "date": "2019-11-04 06:40:43Z" + "api version": "1.1.128", + "comment": "from git branch: github-master commit: d4b6925d02d0c917403fb8743c0289dd67b027f1", + "date": "2019-11-17 15:45:54Z" }, "validation": { "vkGetInstanceProcAddr": { @@ -214,7 +214,7 @@ }, { "vuid": "VUID-VkPhysicalDeviceProperties2-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceDepthStencilResolvePropertiesKHR, VkPhysicalDeviceDescriptorIndexingPropertiesEXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDriverPropertiesKHR, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsPropertiesKHR, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceInlineUniformBlockPropertiesEXT, VkPhysicalDeviceLineRasterizationPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, VkPhysicalDeviceShaderCoreProperties2AMD, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT, VkPhysicalDeviceTimelineSemaphorePropertiesKHR, VkPhysicalDeviceTransformFeedbackPropertiesEXT, or VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceDepthStencilResolvePropertiesKHR, VkPhysicalDeviceDescriptorIndexingPropertiesEXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDriverPropertiesKHR, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsPropertiesKHR, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceInlineUniformBlockPropertiesEXT, VkPhysicalDeviceLineRasterizationPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePerformanceQueryPropertiesKHR, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, VkPhysicalDeviceShaderCoreProperties2AMD, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT, VkPhysicalDeviceTimelineSemaphorePropertiesKHR, VkPhysicalDeviceTransformFeedbackPropertiesEXT, or VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT" }, { "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique", @@ -298,6 +298,50 @@ } ] }, + "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-pCounterCount-parameter", + "text": " pCounterCount must be a valid pointer to a uint32_t value" + }, + { + "vuid": "VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-pCounters-parameter", + "text": " If the value referenced by pCounterCount is not 0, and pCounters is not NULL, pCounters must be a valid pointer to an array of pCounterCount VkPerformanceCounterKHR structures" + }, + { + "vuid": "VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-pCounterDescriptions-parameter", + "text": " If the value referenced by pCounterCount is not 0, and pCounterDescriptions is not NULL, pCounterDescriptions must be a valid pointer to an array of pCounterCount VkPerformanceCounterDescriptionKHR structures" + } + ] + }, + "VkPerformanceCounterKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkPerformanceCounterKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR" + }, + { + "vuid": "VUID-VkPerformanceCounterKHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, + "VkPerformanceCounterDescriptionKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkPerformanceCounterDescriptionKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR" + }, + { + "vuid": "VUID-VkPerformanceCounterDescriptionKHR-pNext-pNext", + "text": " pNext must be NULL" + } + ] + }, "vkEnumeratePhysicalDeviceGroups": { "(VK_VERSION_1_1,VK_KHR_device_group_creation)": [ { @@ -388,7 +432,7 @@ }, { "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice8BitStorageFeaturesKHR, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceHostQueryResetFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeaturesKHR, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeaturesEXT, VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR, VkPhysicalDeviceShaderAtomicInt64FeaturesKHR, VkPhysicalDeviceShaderClockFeaturesKHR, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderFloat16Int8FeaturesKHR, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, VkPhysicalDeviceTimelineSemaphoreFeaturesKHR, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVulkanMemoryModelFeaturesKHR, or VkPhysicalDeviceYcbcrImageArraysFeaturesEXT" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice8BitStorageFeaturesKHR, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceHostQueryResetFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeaturesKHR, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeaturesEXT, VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR, VkPhysicalDeviceShaderAtomicInt64FeaturesKHR, VkPhysicalDeviceShaderClockFeaturesKHR, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderFloat16Int8FeaturesKHR, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, VkPhysicalDeviceTimelineSemaphoreFeaturesKHR, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVulkanMemoryModelFeaturesKHR, or VkPhysicalDeviceYcbcrImageArraysFeaturesEXT" }, { "vuid": "VUID-VkDeviceCreateInfo-sType-unique", @@ -1004,6 +1048,10 @@ "vuid": "VUID-vkQueueSubmit-pSubmits-02207", "text": " If any element of pSubmits->pCommandBuffers includes a Queue Family Transfer Acquire Operation, there must exist a previously submitted Queue Family Transfer Release Operation on a queue in the queue family identified by the acquire operation, with parameters matching the acquire operation as defined in the definition of such acquire operations, and which happens before the acquire operation." }, + { + "vuid": "VUID-vkQueueSubmit-pSubmits-02808", + "text": " Any resource created with VK_SHARING_MODE_EXCLUSIVE that is read by an operation specified by pSubmits must not be owned by any queue family other than the one which queue belongs to, at the time it is executed" + }, { "vuid": "VUID-vkQueueSubmit-queue-parameter", "text": " queue must be a valid VkQueue handle" @@ -1026,6 +1074,12 @@ "vuid": "VUID-vkQueueSubmit-pWaitSemaphores-03238", "text": " All elements of the pWaitSemaphores member of all elements of pSubmits created with a VkSemaphoreTypeKHR of VK_SEMAPHORE_TYPE_BINARY_KHR must reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends (if any) must have also been submitted for execution." } + ], + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkQueueSubmit-pCommandBuffers-03220", + "text": " If a command recorded into any element of pCommandBuffers was a vkCmdBeginQuery whose queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the profiling lock must have been held continuously on the VkDevice that queue was retrieved from, throughout recording of those command buffers." + } ] }, "VkSubmitInfo": { @@ -1052,7 +1106,7 @@ }, { "vuid": "VUID-VkSubmitInfo-pNext-pNext", - "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkD3D12FenceSubmitInfoKHR, VkDeviceGroupSubmitInfo, VkProtectedSubmitInfo, VkTimelineSemaphoreSubmitInfoKHR, VkWin32KeyedMutexAcquireReleaseInfoKHR, or VkWin32KeyedMutexAcquireReleaseInfoNV" + "text": " Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkD3D12FenceSubmitInfoKHR, VkDeviceGroupSubmitInfo, VkPerformanceQuerySubmitInfoKHR, VkProtectedSubmitInfo, VkTimelineSemaphoreSubmitInfoKHR, VkWin32KeyedMutexAcquireReleaseInfoKHR, or VkWin32KeyedMutexAcquireReleaseInfoNV" }, { "vuid": "VUID-VkSubmitInfo-sType-unique", @@ -1292,6 +1346,18 @@ } ] }, + "VkPerformanceQuerySubmitInfoKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkPerformanceQuerySubmitInfoKHR-counterPassIndex-03221", + "text": " counterPassIndex must be less than the number of counter passes required by any queries within the batch. The required number of counter passes for a performance query is obtained by calling vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR." + }, + { + "vuid": "VUID-VkPerformanceQuerySubmitInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR" + } + ] + }, "vkCmdExecuteCommands": { "core": [ { @@ -1344,7 +1410,7 @@ }, { "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00099", - "text": " If vkCmdExecuteCommands is being called within a render pass instance, and any element of pCommandBuffers was recorded with VkCommandBufferInheritanceInfo::framebuffer not equal to VK_NULL_HANDLE, that VkFramebuffer must match the VkFramebuffer used in the current render pass instance" + "text": " If vkCmdExecuteCommands is being called within a render pass instance, and any element of pCommandBuffers was recorded with VkCommandBufferInheritanceInfo::framebuffer not equal to VK_NULL_HANDLE, that VkFramebuffer must match the VkFramebuffer used in the current render pass instance" }, { "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-00100", @@ -2720,6 +2786,30 @@ "vuid": "VUID-vkCmdWaitEvents-srcQueueFamilyIndex-02803", "text": " The srcQueueFamilyIndex and dstQueueFamilyIndex members of any element of pBufferMemoryBarriers or pImageMemoryBarriers must be equal." }, + { + "vuid": "VUID-vkCmdWaitEvents-srcAccessMask-02809", + "text": " The srcAccessMask member of each element of pMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstAccessMask-02810", + "text": " The dstAccessMask member of each element of pMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdWaitEvents-srcAccessMask-02811", + "text": " The srcAccessMask member of each element of pBufferMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstAccessMask-02812", + "text": " The dstAccessMask member of each element of pBufferMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdWaitEvents-srcAccessMask-02813", + "text": " The srcAccessMask member of each element of pImageMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdWaitEvents-dstAccessMask-02814", + "text": " The dstAccessMask member of any element of pImageMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types" + }, { "vuid": "VUID-vkCmdWaitEvents-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -2834,15 +2924,31 @@ }, { "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-01183", - "text": " Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages." + "text": " Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages" }, { - "vuid": "VUID-vkCmdPipelineBarrier-pMemoryBarriers-01184", - "text": " Each element of pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers must not have any access flag included in its srcAccessMask member if that bit is not supported by any of the pipeline stages in srcStageMask, as specified in the table of supported access types." + "vuid": "VUID-vkCmdPipelineBarrier-srcAccessMask-02815", + "text": " The srcAccessMask member of each element of pMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types" }, { - "vuid": "VUID-vkCmdPipelineBarrier-pMemoryBarriers-01185", - "text": " Each element of pMemoryBarriers, pBufferMemoryBarriers and pImageMemoryBarriers must not have any access flag included in its dstAccessMask member if that bit is not supported by any of the pipeline stages in dstStageMask, as specified in the table of supported access types." + "vuid": "VUID-vkCmdPipelineBarrier-dstAccessMask-02816", + "text": " The dstAccessMask member of each element of pMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-02817", + "text": " For any element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-02818", + "text": " For any element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-02819", + "text": " For any element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-02820", + "text": " For any element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types" }, { "vuid": "VUID-vkCmdPipelineBarrier-commandBuffer-parameter", @@ -2984,14 +3090,6 @@ "vuid": "VUID-VkBufferMemoryBarrier-pNext-pNext", "text": " pNext must be NULL" }, - { - "vuid": "VUID-VkBufferMemoryBarrier-srcAccessMask-parameter", - "text": " srcAccessMask must be a valid combination of VkAccessFlagBits values" - }, - { - "vuid": "VUID-VkBufferMemoryBarrier-dstAccessMask-parameter", - "text": " dstAccessMask must be a valid combination of VkAccessFlagBits values" - }, { "vuid": "VUID-VkBufferMemoryBarrier-buffer-parameter", "text": " buffer must be a valid VkBuffer handle" @@ -3096,14 +3194,6 @@ "vuid": "VUID-VkImageMemoryBarrier-pNext-pNext", "text": " pNext must be NULL or a pointer to a valid instance of VkSampleLocationsInfoEXT" }, - { - "vuid": "VUID-VkImageMemoryBarrier-srcAccessMask-parameter", - "text": " srcAccessMask must be a valid combination of VkAccessFlagBits values" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-dstAccessMask-parameter", - "text": " dstAccessMask must be a valid combination of VkAccessFlagBits values" - }, { "vuid": "VUID-VkImageMemoryBarrier-oldLayout-parameter", "text": " oldLayout must be a valid VkImageLayout value" @@ -3322,6 +3412,10 @@ "vuid": "VUID-VkRenderPassCreateInfo-sType-unique", "text": " Each sType member in the pNext chain must be unique" }, + { + "vuid": "VUID-VkRenderPassCreateInfo-flags-zerobitmask", + "text": " flags must be 0" + }, { "vuid": "VUID-VkRenderPassCreateInfo-pAttachments-parameter", "text": " If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription structures" @@ -3894,6 +3988,10 @@ "vuid": "VUID-VkRenderPassCreateInfo2KHR-pNext-pNext", "text": " pNext must be NULL or a pointer to a valid instance of VkRenderPassFragmentDensityMapCreateInfoEXT" }, + { + "vuid": "VUID-VkRenderPassCreateInfo2KHR-flags-zerobitmask", + "text": " flags must be 0" + }, { "vuid": "VUID-VkRenderPassCreateInfo2KHR-pAttachments-parameter", "text": " If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription2KHR structures" @@ -5307,8 +5405,8 @@ "text": " pNext must be NULL or a pointer to a valid instance of VkShaderModuleValidationCacheCreateInfoEXT" }, { - "vuid": "VUID-VkShaderModuleCreateInfo-flags-parameter", - "text": " flags must be a valid combination of VkShaderModuleCreateFlagBits values" + "vuid": "VUID-VkShaderModuleCreateInfo-flags-zerobitmask", + "text": " flags must be 0" }, { "vuid": "VUID-VkShaderModuleCreateInfo-pCode-parameter", @@ -7062,7 +7160,7 @@ "core": [ { "vuid": "VUID-vkAllocateMemory-pAllocateInfo-01713", - "text": " pAllocateInfo->allocationSize must be less than or equal to VkPhysicalDeviceMemoryProperties::memoryHeaps[pAllocateInfo->memoryTypeIndex].size as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from." + "text": " pAllocateInfo->allocationSize must be less than or equal to VkPhysicalDeviceMemoryProperties::memoryHeaps[memindex].size where memindex = VkPhysicalDeviceMemoryProperties::memoryTypes[pAllocateInfo->memoryTypeIndex].heapIndex as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from." }, { "vuid": "VUID-vkAllocateMemory-pAllocateInfo-01714", @@ -8356,10 +8454,6 @@ "vuid": "VUID-VkBufferViewCreateInfo-offset-00925", "text": " offset must be less than the size of buffer" }, - { - "vuid": "VUID-VkBufferViewCreateInfo-offset-02749", - "text": " If the texelBufferAlignment feature is not enabled, offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment" - }, { "vuid": "VUID-VkBufferViewCreateInfo-range-00928", "text": " If range is not equal to VK_WHOLE_SIZE, range must be greater than 0" @@ -8413,7 +8507,17 @@ "text": " format must be a valid VkFormat value" } ], + "!(VK_EXT_texel_buffer_alignment)": [ + { + "vuid": "VUID-VkBufferViewCreateInfo-offset-00926", + "text": " offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment" + } + ], "(VK_EXT_texel_buffer_alignment)": [ + { + "vuid": "VUID-VkBufferViewCreateInfo-offset-02749", + "text": " If the texelBufferAlignment feature is not enabled, offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment" + }, { "vuid": "VUID-VkBufferViewCreateInfo-buffer-02750", "text": " If the texelBufferAlignment feature is enabled and if buffer was created with usage containing VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, offset must be a multiple of the lesser of VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::storageTexelBufferOffsetAlignmentBytes or, if VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::storageTexelBufferOffsetSingleTexelAlignment is VK_TRUE, the size of a texel of the requested format. If the size of a texel is a multiple of three bytes, then the size of a single component of format is used instead" @@ -10968,10 +11072,6 @@ "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01078", "text": " If any of addressModeU, addressModeV or addressModeW are VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, borderColor must be a valid VkBorderColor value" }, - { - "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01079", - "text": " If the VK_KHR_sampler_mirror_clamp_to_edge extension is not enabled, addressModeU, addressModeV and addressModeW must not be VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE" - }, { "vuid": "VUID-VkSamplerCreateInfo-compareEnable-01080", "text": " If compareEnable is VK_TRUE, compareOp must be a valid VkCompareOp value" @@ -11033,6 +11133,12 @@ "text": " The sampler reduction mode must be set to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT if sampler Y’CBCR conversion is enabled" } ], + "(VK_KHR_sampler_mirror_clamp_to_edge)": [ + { + "vuid": "VUID-VkSamplerCreateInfo-addressModeU-01079", + "text": " If the VK_KHR_sampler_mirror_clamp_to_edge extension is not enabled, addressModeU, addressModeV and addressModeW must not be VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE" + } + ], "(VK_IMG_filter_cubic,VK_EXT_filter_cubic)": [ { "vuid": "VUID-VkSamplerCreateInfo-magFilter-01081", @@ -12944,7 +13050,7 @@ }, { "vuid": "VUID-VkQueryPoolCreateInfo-pNext-pNext", - "text": " pNext must be NULL" + "text": " pNext must be NULL or a pointer to a valid instance of VkQueryPoolPerformanceCreateInfoKHR" }, { "vuid": "VUID-VkQueryPoolCreateInfo-flags-zerobitmask", @@ -12954,6 +13060,56 @@ "vuid": "VUID-VkQueryPoolCreateInfo-queryType-parameter", "text": " queryType must be a valid VkQueryType value" } + ], + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkQueryPoolCreateInfo-queryType-03222", + "text": " If queryType is VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the pNext chain must contain a structure of type VkQueryPoolPerformanceCreateInfoKHR" + } + ] + }, + "VkQueryPoolPerformanceCreateInfoKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-queueFamilyIndex-03236", + "text": " queueFamilyIndex must be a valid queue family index of the device." + }, + { + "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-performanceCounterQueryPools-03237", + "text": " The performanceCounterQueryPools feature must be enabled" + }, + { + "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-pCounterIndices-03321", + "text": " Each element of pCounterIndices must be in the range of counters reported by vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR for the queue family specified in queueFamilyIndex." + }, + { + "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR" + }, + { + "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-pCounterIndices-parameter", + "text": " pCounterIndices must be a valid pointer to an array of counterIndexCount uint32_t values" + }, + { + "vuid": "VUID-VkQueryPoolPerformanceCreateInfoKHR-counterIndexCount-arraylength", + "text": " counterIndexCount must be greater than 0" + } + ] + }, + "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-physicalDevice-parameter", + "text": " physicalDevice must be a valid VkPhysicalDevice handle" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-pPerformanceQueryCreateInfo-parameter", + "text": " pPerformanceQueryCreateInfo must be a valid pointer to a valid VkQueryPoolPerformanceCreateInfoKHR structure" + }, + { + "vuid": "VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-pNumPasses-parameter", + "text": " pNumPasses must be a valid pointer to a uint32_t value" + } ] }, "vkDestroyQueryPool": { @@ -13140,6 +13296,24 @@ "vuid": "VUID-vkCmdBeginQuery-queryType-02328", "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT then VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackQueries must be supported" } + ], + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkCmdBeginQuery-queryPool-03223", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the profiling lock must have been held before vkBeginCommandBuffer was called on commandBuffer." + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryPool-03224", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one of the counters used to create queryPool was VK_QUERY_SCOPE_COMMAND_BUFFER_KHR, the query begin must be the first recorded command in commandBuffer." + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryPool-03225", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one of the counters used to create queryPool was VK_QUERY_SCOPE_RENDER_PASS_KHR, the begin command must not be recorded within a render pass instance." + }, + { + "vuid": "VUID-vkCmdBeginQuery-queryPool-03226", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and another query pool with a queryType VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR has been used within commandBuffer, its parent primary command buffer or secondary command buffer recorded within the same parent primary command buffer as commandBuffer, the performanceCounterMultipleQueryPools feature must be enabled." + } ] }, "vkCmdBeginQueryIndexedEXT": { @@ -13228,6 +13402,24 @@ "vuid": "VUID-vkCmdBeginQueryIndexedEXT-query-00808", "text": " If called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool" } + ], + "(VK_EXT_transform_feedback)+(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryPool-03223", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the profiling lock must have been held before vkBeginCommandBuffer was called on commandBuffer." + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryPool-03224", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one of the counters used to create queryPool was VK_QUERY_SCOPE_COMMAND_BUFFER_KHR, the query begin must be the first recorded command in commandBuffer." + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryPool-03225", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one of the counters used to create queryPool was VK_QUERY_SCOPE_RENDER_PASS_KHR, the begin command must not be recorded within a render pass instance." + }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryPool-03226", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and another query pool with a queryType VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR has been used within commandBuffer, its parent primary command buffer or secondary command buffer recorded within the same parent primary command buffer as commandBuffer, the performanceCounterMultipleQueryPools feature must be enabled." + } ] }, "vkCmdEndQuery": { @@ -13272,6 +13464,16 @@ "vuid": "VUID-vkCmdEndQuery-query-00812", "text": " If vkCmdEndQuery is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool" } + ], + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkCmdEndQuery-queryPool-03227", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one or more of the counters used to create queryPool was VK_QUERY_SCOPE_COMMAND_BUFFER_KHR, the vkCmdEndQuery must be the last recorded command in commandBuffer." + }, + { + "vuid": "VUID-vkCmdEndQuery-queryPool-03228", + "text": " If queryPool was created with a queryType of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR and one or more of the counters used to create queryPool was VK_QUERY_SCOPE_RENDER_PASS_KHR, the vkCmdEndQuery must not be recorded within a render pass instance." + } ] }, "vkCmdEndQueryIndexedEXT": { @@ -13338,7 +13540,7 @@ }, { "vuid": "VUID-vkGetQueryPoolResults-flags-00814", - "text": " If VK_QUERY_RESULT_64_BIT is not set in flags then pData and stride must be multiples of 4" + "text": " If VK_QUERY_RESULT_64_BIT is not set in flags" }, { "vuid": "VUID-vkGetQueryPoolResults-flags-00815", @@ -13380,6 +13582,20 @@ "vuid": "VUID-vkGetQueryPoolResults-queryPool-parent", "text": " queryPool must have been created, allocated, or retrieved from device" } + ], + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkGetQueryPoolResults-queryType-03229", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, then pData and stride must be multiples of the size of VkPerformanceCounterResultKHR" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-queryType-03230", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, flags must not contain VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, VK_QUERY_RESULT_PARTIAL_BIT or VK_QUERY_RESULT_64_BIT" + }, + { + "vuid": "VUID-vkGetQueryPoolResults-queryType-03231", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the queryPool must have been recorded once for each pass as retrieved via a call to vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR." + } ] }, "vkCmdCopyQueryPoolResults": { @@ -13453,6 +13669,20 @@ "text": " Each of commandBuffer, dstBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice" } ], + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-03232", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, VkPhysicalDevicePerformanceQueryPropertiesKHR::allowCommandBufferQueryCopies must be VK_TRUE" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-03233", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, flags must not contain VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, VK_QUERY_RESULT_PARTIAL_BIT or VK_QUERY_RESULT_64_BIT" + }, + { + "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-03234", + "text": " If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the queryPool must have been submitted once for each pass as retrieved via a call to vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR." + } + ], "(VK_INTEL_performance_query)": [ { "vuid": "VUID-vkCmdCopyQueryPoolResults-queryType-02734", @@ -13510,6 +13740,46 @@ } ] }, + "vkAcquireProfilingLockKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkAcquireProfilingLockKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkAcquireProfilingLockKHR-pInfo-parameter", + "text": " pInfo must be a valid pointer to a valid VkAcquireProfilingLockInfoKHR structure" + } + ] + }, + "VkAcquireProfilingLockInfoKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkAcquireProfilingLockInfoKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR" + }, + { + "vuid": "VUID-VkAcquireProfilingLockInfoKHR-pNext-pNext", + "text": " pNext must be NULL" + }, + { + "vuid": "VUID-VkAcquireProfilingLockInfoKHR-flags-zerobitmask", + "text": " flags must be 0" + } + ] + }, + "vkReleaseProfilingLockKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-vkReleaseProfilingLockKHR-device-03235", + "text": " The profiling lock of device must have been held via a previous successful call to vkAcquireProfilingLockKHR." + }, + { + "vuid": "VUID-vkReleaseProfilingLockKHR-device-parameter", + "text": " device must be a valid VkDevice handle" + } + ] + }, "vkInitializePerformanceApiINTEL": { "(VK_INTEL_performance_query)+(VK_INTEL_performance_query)": [ { @@ -18194,6 +18464,18 @@ "vuid": "VUID-VkPipelineViewportStateCreateInfo-scissorCount-01220", "text": " scissorCount and viewportCount must be identical" }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-x-02821", + "text": " The x and y members of offset member of any element of pScissors must be greater than or equal to 0" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-offset-02822", + "text": " Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow for any element of pScissors" + }, + { + "vuid": "VUID-VkPipelineViewportStateCreateInfo-offset-02823", + "text": " Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow for any element of pScissors" + }, { "vuid": "VUID-VkPipelineViewportStateCreateInfo-sType-sType", "text": " sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO" @@ -19024,15 +19306,15 @@ }, { "vuid": "VUID-vkCmdSetScissor-x-00595", - "text": " The x and y members of offset must be greater than or equal to 0" + "text": " The x and y members of offset member of any element of pScissors must be greater than or equal to 0" }, { "vuid": "VUID-vkCmdSetScissor-offset-00596", - "text": " Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow" + "text": " Evaluation of (offset.x + extent.width) must not cause a signed integer addition overflow for any element of pScissors" }, { "vuid": "VUID-vkCmdSetScissor-offset-00597", - "text": " Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow" + "text": " Evaluation of (offset.y + extent.height) must not cause a signed integer addition overflow for any element of pScissors" }, { "vuid": "VUID-vkCmdSetScissor-commandBuffer-parameter", @@ -22201,7 +22483,7 @@ ] }, "vkGetPhysicalDeviceSurfaceCapabilities2KHR": { - "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_EXT_full_screen_exclusive,VK_KHR_win32_surface)": [ + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_EXT_full_screen_exclusive+VK_KHR_win32_surface)": [ { "vuid": "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-pNext-02671", "text": " If an instance of VkSurfaceCapabilitiesFullScreenExclusiveEXT is included in the pNext chain of pSurfaceCapabilities, an instance of VkSurfaceFullScreenExclusiveWin32InfoEXT must be included in the pNext chain of pSurfaceInfo." @@ -22223,7 +22505,7 @@ ] }, "VkPhysicalDeviceSurfaceInfo2KHR": { - "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_KHR_win32_surface,VK_EXT_full_screen_exclusive)": [ + "(VK_KHR_surface)+(VK_KHR_get_surface_capabilities2)+(VK_KHR_win32_surface+VK_EXT_full_screen_exclusive)": [ { "vuid": "VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-02672", "text": " If the pNext chain includes an instance of VkSurfaceFullScreenExclusiveInfoEXT with its fullScreenExclusive member set to VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT, and surface was created using vkCreateWin32SurfaceKHR, an instance of VkSurfaceFullScreenExclusiveWin32InfoEXT must be present in the pNext chain" @@ -22841,7 +23123,7 @@ "text": " If flags contains VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR, then VkSurfaceProtectedCapabilitiesKHR::supportsProtected must be VK_TRUE in the VkSurfaceProtectedCapabilitiesKHR structure returned by vkGetPhysicalDeviceSurfaceCapabilities2KHR for surface" } ], - "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_full_screen_exclusive,VK_KHR_win32_surface)": [ + "(VK_KHR_surface)+(VK_KHR_swapchain)+(VK_EXT_full_screen_exclusive+VK_KHR_win32_surface)": [ { "vuid": "VUID-VkSwapchainCreateInfoKHR-pNext-02679", "text": " If the pNext chain includes an instance of VkSurfaceFullScreenExclusiveInfoEXT with its fullScreenExclusive member set to VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT, and surface was created using vkCreateWin32SurfaceKHR, an instance of VkSurfaceFullScreenExclusiveWin32InfoEXT must be present in the pNext chain" @@ -24512,6 +24794,22 @@ } ] }, + "VkPhysicalDevicePerformanceQueryFeaturesKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkPhysicalDevicePerformanceQueryFeaturesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR" + } + ] + }, + "VkPhysicalDevicePerformanceQueryPropertiesKHR": { + "(VK_KHR_performance_query)": [ + { + "vuid": "VUID-VkPhysicalDevicePerformanceQueryPropertiesKHR-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR" + } + ] + }, "VkPhysicalDeviceShadingRateImagePropertiesNV": { "(VK_NV_shading_rate_image)": [ { diff --git a/registry/vk.xml b/registry/vk.xml index 20f769c..26ff4cc 100644 --- a/registry/vk.xml +++ b/registry/vk.xml @@ -154,7 +154,7 @@ server. // Vulkan 1.1 version number #define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 127 +#define VK_HEADER_VERSION 128 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; @@ -269,9 +269,11 @@ typedef void CAMetalLayer; typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; typedef VkFlags VkPipelineCreationFeedbackFlagsEXT; + typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; + typedef VkFlags VkAcquireProfilingLockFlagsKHR; + typedef VkFlags VkSemaphoreWaitFlagsKHR; typedef VkFlags VkPipelineCompilerControlFlagsAMD; typedef VkFlags VkShaderCorePropertiesFlagsAMD; - typedef VkFlags VkSemaphoreWaitFlagsKHR; WSI extensions typedef VkFlags VkCompositeAlphaFlagsKHR; @@ -338,7 +340,6 @@ typedef void CAMetalLayer; typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT; typedef VkFlags VkSwapchainImageUsageFlagsANDROID; - Types which can be void pointers or class pointers, selected at compile time VK_DEFINE_HANDLE(VkInstance) VK_DEFINE_HANDLE(VkPhysicalDevice) @@ -508,6 +509,11 @@ typedef void CAMetalLayer; + + + + + @@ -889,8 +895,8 @@ typedef void CAMetalLayer; VkStructureType sType const void* pNext - VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize - VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize uint32_t srcQueueFamilyIndexQueue family to transition ownership from uint32_t dstQueueFamilyIndexQueue family to transition ownership to VkBuffer bufferBuffer to sync @@ -900,8 +906,8 @@ typedef void CAMetalLayer; VkStructureType sType const void* pNext - VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize - VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize + VkAccessFlags srcAccessMaskMemory accesses from the source of the dependency to synchronize + VkAccessFlags dstAccessMaskMemory accesses from the destination of the dependency to synchronize VkImageLayout oldLayoutCurrent layout of the image VkImageLayout newLayoutNew layout to transition the image to uint32_t srcQueueFamilyIndexQueue family to transition ownership from @@ -1364,7 +1370,7 @@ typedef void CAMetalLayer; VkStructureType sType const void* pNext - VkRenderPassCreateFlags flags + VkRenderPassCreateFlags flags uint32_t attachmentCount const VkAttachmentDescription* pAttachments uint32_t subpassCount @@ -3314,7 +3320,7 @@ typedef void CAMetalLayer; VkStructureType sType const void* pNext - VkRenderPassCreateFlags flags + VkRenderPassCreateFlags flags uint32_t attachmentCount const VkAttachmentDescription2KHR* pAttachments uint32_t subpassCount @@ -3918,8 +3924,8 @@ typedef void CAMetalLayer; VkStructureType sType - const void* pNext - VkBool32 textureCompressionASTC_HDR + void* pNext + VkBool32 textureCompressionASTC_HDR VkStructureType sType @@ -3987,6 +3993,58 @@ typedef void CAMetalLayer; void* pNext VkBool32 fullScreenExclusiveSupported + + VkStructureType sType + void* pNext + VkBool32 performanceCounterQueryPoolsperformance counters supported in query pools + VkBool32 performanceCounterMultipleQueryPoolsperformance counters from multiple query pools can be accessed in the same primary command buffer + + VkStructureType sType + void* pNext + VkBool32 allowCommandBufferQueryCopiesFlag to specify whether performance queries are allowed to be used in vkCmdCopyQueryPoolResults + + + VkStructureType sType + const void* pNext + VkPerformanceCounterUnitKHR unit + VkPerformanceCounterScopeKHR scope + VkPerformanceCounterStorageKHR storage + uint8_t uuid[VK_UUID_SIZE] + + + VkStructureType sType + const void* pNext + VkPerformanceCounterDescriptionFlagsKHR flags + char name[VK_MAX_DESCRIPTION_SIZE] + char category[VK_MAX_DESCRIPTION_SIZE] + char description[VK_MAX_DESCRIPTION_SIZE] + + + VkStructureType sType + const void* pNext + uint32_t queueFamilyIndex + uint32_t counterIndexCount + const uint32_t* pCounterIndices + + + int32_t int32 + int64_t int64 + uint32_t uint32 + uint64_t uint64 + float float32 + double float64 + + + VkStructureType sType + const void* pNext + VkAcquireProfilingLockFlagsKHR flagsAcquire profiling lock flags + uint64_t timeout + + + VkStructureType sType + const void* pNext + uint32_t counterPassIndexIndex for which counter pass to submit + VkStructureType sType const void* pNext @@ -5475,6 +5533,38 @@ typedef void CAMetalLayer; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -6025,7 +6115,7 @@ typedef void CAMetalLayer; VkDescriptorPool descriptorPool const VkAllocationCallbacks* pAllocator - + VkResult vkResetDescriptorPool VkDevice device VkDescriptorPool descriptorPool @@ -6040,7 +6130,7 @@ typedef void CAMetalLayer; const VkDescriptorSetAllocateInfo* pAllocateInfo VkDescriptorSet* pDescriptorSets - + VkResult vkFreeDescriptorSets VkDevice device VkDescriptorPool descriptorPool @@ -7732,17 +7822,6 @@ typedef void CAMetalLayer; const VkAllocationCallbacks* pAllocator VkPipeline* pPipelines - - VkResult vkGetImageDrmFormatModifierPropertiesEXT - VkDevice device - VkImage image - VkImageDrmFormatModifierPropertiesEXT* pProperties - - - VkDeviceAddress vkGetBufferDeviceAddressEXT - VkDevice device - const VkBufferDeviceAddressInfoEXT* pInfo - VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV VkPhysicalDevice physicalDevice @@ -7777,6 +7856,40 @@ typedef void CAMetalLayer; VkDevice device VkSwapchainKHR swapchain + + VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + uint32_t* pCounterCount + VkPerformanceCounterKHR* pCounters + VkPerformanceCounterDescriptionKHR* pCounterDescriptions + + + void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR + VkPhysicalDevice physicalDevice + const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo + uint32_t* pNumPasses + + + VkResult vkAcquireProfilingLockKHR + VkDevice device + const VkAcquireProfilingLockInfoKHR* pInfo + + + void vkReleaseProfilingLockKHR + VkDevice device + + + VkResult vkGetImageDrmFormatModifierPropertiesEXT + VkDevice device + VkImage image + VkImageDrmFormatModifierPropertiesEXT* pProperties + + + VkDeviceAddress vkGetBufferDeviceAddressEXT + VkDevice device + const VkBufferDeviceAddressInfoEXT* pInfo + VkResult vkCreateHeadlessSurfaceEXT VkInstance instance @@ -8079,7 +8192,7 @@ typedef void CAMetalLayer; - + @@ -8147,7 +8260,8 @@ typedef void CAMetalLayer; - + + @@ -9821,10 +9935,37 @@ typedef void CAMetalLayer; - + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -10225,6 +10366,7 @@ typedef void CAMetalLayer; + @@ -11388,7 +11530,7 @@ typedef void CAMetalLayer; - + @@ -11641,6 +11783,8 @@ typedef void CAMetalLayer; + + @@ -11680,5 +11824,15 @@ typedef void CAMetalLayer; + + + + + + + + + +