# define VULKAN_HPP_ASSERT assert
#endif
-#if defined(__linux__) || defined(__APPLE__)
-# include <dlfcn.h>
+#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 <dlfcn.h>
+# endif
+
+# if defined(_WIN32)
+# include <windows.h>
+# 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
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 );
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 );
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 );
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 );
}
}
+ 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,
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
};
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";
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,
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";
return "{ " + result.substr(0, result.size() - 3) + " }";
}
+ enum class AcquireProfilingLockFlagBitsKHR
+ {};
+
+ VULKAN_HPP_INLINE std::string to_string( AcquireProfilingLockFlagBitsKHR )
+ {
+ return "(void)";
+ }
+
+ using AcquireProfilingLockFlagsKHR = Flags<AcquireProfilingLockFlagBitsKHR, VkAcquireProfilingLockFlagsKHR>;
+
+ VULKAN_HPP_INLINE std::string to_string( AcquireProfilingLockFlagsKHR )
+ {
+ return "{}";
+ }
+
#ifdef VK_USE_PLATFORM_ANDROID_KHR
enum class AndroidSurfaceCreateFlagBitsKHR
{};
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<PerformanceCounterDescriptionFlagBitsKHR, VkPerformanceCounterDescriptionFlagsKHR>;
+
+ template <> struct FlagTraits<PerformanceCounterDescriptionFlagBitsKHR>
+ {
+ 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
{};
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,
: 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 )
{
struct AccelerationStructureInfoNV;
struct AccelerationStructureMemoryRequirementsInfoNV;
struct AcquireNextImageInfoKHR;
+ struct AcquireProfilingLockInfoKHR;
struct AllocationCallbacks;
#ifdef VK_USE_PLATFORM_ANDROID_KHR
struct AndroidHardwareBufferFormatPropertiesANDROID;
struct Offset3D;
struct PastPresentationTimingGOOGLE;
struct PerformanceConfigurationAcquireInfoINTEL;
+ struct PerformanceCounterDescriptionKHR;
+ struct PerformanceCounterKHR;
+ union PerformanceCounterResultKHR;
struct PerformanceMarkerInfoINTEL;
struct PerformanceOverrideInfoINTEL;
+ struct PerformanceQuerySubmitInfoKHR;
struct PerformanceStreamMarkerInfoINTEL;
union PerformanceValueDataINTEL;
struct PerformanceValueINTEL;
struct PhysicalDeviceMultiviewProperties;
using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
struct PhysicalDevicePCIBusInfoPropertiesEXT;
+ struct PhysicalDevicePerformanceQueryFeaturesKHR;
+ struct PhysicalDevicePerformanceQueryPropertiesKHR;
struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
struct PhysicalDevicePointClippingProperties;
using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
struct PushConstantRange;
struct QueryPoolCreateInfo;
struct QueryPoolCreateInfoINTEL;
+ struct QueryPoolPerformanceCreateInfoKHR;
struct QueueFamilyCheckpointPropertiesNV;
struct QueueFamilyProperties;
struct QueueFamilyProperties2;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ Result acquireProfilingLockKHR( const vk::AcquireProfilingLockInfoKHR* pInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ ResultValueType<void>::type acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result allocateCommandBuffers( const vk::CommandBufferAllocateInfo* pAllocateInfo, vk::CommandBuffer* pCommandBuffers, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ResultValueType<vk::Fence>::type registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ResultValueType<vk::Fence>::type registerDisplayEventEXT( vk::DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type registerDisplayEventEXTUnique( vk::DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ResultValueType<void>::type releasePerformanceConfigurationINTEL( vk::PerformanceConfigurationINTEL configuration, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ void releaseProfilingLockKHR(Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result resetCommandPool( vk::CommandPool commandPool, vk::CommandPoolResetFlags flags, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ 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 Allocator = std::allocator<PerformanceCounterDescriptionKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR,Allocator>>::type enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, ArrayProxy<vk::PerformanceCounterKHR> counters, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+ template<typename Allocator = std::allocator<PerformanceCounterDescriptionKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR,Allocator>>::type enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, ArrayProxy<vk::PerformanceCounterKHR> counters, Allocator const& vectorAllocator, Dispatch const &d ) const;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
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
template<typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ 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<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+ uint32_t getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const &d = VULKAN_HPP_DEFAULT_DISPATCHER ) const VULKAN_HPP_NOEXCEPT;
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
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
template<typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ResultValueType<uint32_t>::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<VkGeometryTrianglesNV*>(this) = rhs;
- }
-
- GeometryTrianglesNV& operator=( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkGeometryTrianglesNV*>(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,
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<vk::GeometryTrianglesNV const *>(&rhs);
return *this;
}
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<GeometryTrianglesNV>::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<VkGeometryAABBNV*>(this) = rhs;
- }
-
- GeometryAABBNV& operator=( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkGeometryAABBNV*>(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<vk::GeometryAABBNV const *>(&rhs);
return *this;
}
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<GeometryAABBNV>::value, "struct wrapper is not a standard layout!" );
GeometryDataNV( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkGeometryDataNV*>(this) = rhs;
+ *this = rhs;
}
GeometryDataNV& operator=( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkGeometryDataNV*>(this) = rhs;
+ *this = *reinterpret_cast<vk::GeometryDataNV const *>(&rhs);
return *this;
}
static_assert( sizeof( GeometryDataNV ) == sizeof( VkGeometryDataNV ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<GeometryDataNV>::value, "struct wrapper is not a standard layout!" );
- 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<VkGeometryNV*>(this) = rhs;
- }
-
- GeometryNV& operator=( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkGeometryNV*>(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<vk::GeometryNV const *>(&rhs);
return *this;
}
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<GeometryNV>::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<VkAccelerationStructureInfoNV*>(this) = rhs;
- }
-
- AccelerationStructureInfoNV& operator=( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkAccelerationStructureInfoNV*>(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<vk::AccelerationStructureInfoNV const *>(&rhs);
return *this;
}
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<AccelerationStructureInfoNV>::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<VkAccelerationStructureCreateInfoNV*>(this) = rhs;
- }
-
- AccelerationStructureCreateInfoNV& operator=( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkAccelerationStructureCreateInfoNV*>(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<vk::AccelerationStructureCreateInfoNV const *>(&rhs);
return *this;
}
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<AccelerationStructureCreateInfoNV>::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<VkAccelerationStructureMemoryRequirementsInfoNV*>(this) = rhs;
- }
-
- AccelerationStructureMemoryRequirementsInfoNV& operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>(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<vk::AccelerationStructureMemoryRequirementsInfoNV const *>(&rhs);
return *this;
}
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<AccelerationStructureMemoryRequirementsInfoNV>::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<VkAcquireNextImageInfoKHR*>(this) = rhs;
- }
-
- AcquireNextImageInfoKHR& operator=( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkAcquireNextImageInfoKHR*>(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<vk::AcquireNextImageInfoKHR const *>(&rhs);
return *this;
}
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<AcquireNextImageInfoKHR>::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<vk::AcquireProfilingLockInfoKHR const *>(&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<const VkAcquireProfilingLockInfoKHR*>( this );
+ }
+
+ operator VkAcquireProfilingLockInfoKHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkAcquireProfilingLockInfoKHR*>( 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<AcquireProfilingLockInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
struct AllocationCallbacks
{
VULKAN_HPP_CONSTEXPR AllocationCallbacks( void* pUserData_ = nullptr,
AllocationCallbacks( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkAllocationCallbacks*>(this) = rhs;
+ *this = rhs;
}
AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkAllocationCallbacks*>(this) = rhs;
+ *this = *reinterpret_cast<vk::AllocationCallbacks const *>(&rhs);
return *this;
}
ComponentMapping( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkComponentMapping*>(this) = rhs;
+ *this = rhs;
}
ComponentMapping& operator=( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkComponentMapping*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ComponentMapping const *>(&rhs);
return *this;
}
#ifdef VK_USE_PLATFORM_ANDROID_KHR
- namespace layout
- {
- struct AndroidHardwareBufferFormatPropertiesANDROID
- {
- protected:
- AndroidHardwareBufferFormatPropertiesANDROID() VULKAN_HPP_NOEXCEPT
- {}
-
- AndroidHardwareBufferFormatPropertiesANDROID( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(this) = rhs;
- }
-
- AndroidHardwareBufferFormatPropertiesANDROID& operator=( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(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
+ struct 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<vk::AndroidHardwareBufferFormatPropertiesANDROID const *>(&rhs);
return *this;
}
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<AndroidHardwareBufferFormatPropertiesANDROID>::value, "struct wrapper is not a standard layout!" );
#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<VkAndroidHardwareBufferPropertiesANDROID*>(this) = rhs;
- }
-
- AndroidHardwareBufferPropertiesANDROID& operator=( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>(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<vk::AndroidHardwareBufferPropertiesANDROID const *>(&rhs);
return *this;
}
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<AndroidHardwareBufferPropertiesANDROID>::value, "struct wrapper is not a standard layout!" );
#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<VkAndroidHardwareBufferUsageANDROID*>(this) = rhs;
- }
-
- AndroidHardwareBufferUsageANDROID& operator=( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(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<vk::AndroidHardwareBufferUsageANDROID const *>(&rhs);
return *this;
}
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<AndroidHardwareBufferUsageANDROID>::value, "struct wrapper is not a standard layout!" );
#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<VkAndroidSurfaceCreateInfoKHR*>(this) = rhs;
- }
-
- AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR*>(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<vk::AndroidSurfaceCreateInfoKHR const *>(&rhs);
return *this;
}
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<AndroidSurfaceCreateInfoKHR>::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<VkApplicationInfo*>(this) = rhs;
- }
-
- ApplicationInfo& operator=( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkApplicationInfo*>(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<vk::ApplicationInfo const *>(&rhs);
return *this;
}
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<ApplicationInfo>::value, "struct wrapper is not a standard layout!" );
AttachmentDescription( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkAttachmentDescription*>(this) = rhs;
+ *this = rhs;
}
AttachmentDescription& operator=( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkAttachmentDescription*>(this) = rhs;
+ *this = *reinterpret_cast<vk::AttachmentDescription const *>(&rhs);
return *this;
}
static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<AttachmentDescription>::value, "struct wrapper is not a standard layout!" );
- 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<VkAttachmentDescription2KHR*>(this) = rhs;
- }
-
- AttachmentDescription2KHR& operator=( VkAttachmentDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkAttachmentDescription2KHR*>(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,
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<vk::AttachmentDescription2KHR const *>(&rhs);
return *this;
}
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<AttachmentDescription2KHR>::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<VkAttachmentDescriptionStencilLayoutKHR*>(this) = rhs;
- }
-
- AttachmentDescriptionStencilLayoutKHR& operator=( VkAttachmentDescriptionStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkAttachmentDescriptionStencilLayoutKHR*>(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<vk::AttachmentDescriptionStencilLayoutKHR const *>(&rhs);
return *this;
}
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<AttachmentDescriptionStencilLayoutKHR>::value, "struct wrapper is not a standard layout!" );
AttachmentReference( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkAttachmentReference*>(this) = rhs;
+ *this = rhs;
}
AttachmentReference& operator=( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkAttachmentReference*>(this) = rhs;
+ *this = *reinterpret_cast<vk::AttachmentReference const *>(&rhs);
return *this;
}
static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<AttachmentReference>::value, "struct wrapper is not a standard layout!" );
- 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<VkAttachmentReference2KHR*>(this) = rhs;
- }
-
- AttachmentReference2KHR& operator=( VkAttachmentReference2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkAttachmentReference2KHR*>(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<vk::AttachmentReference2KHR const *>(&rhs);
return *this;
}
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<AttachmentReference2KHR>::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<VkAttachmentReferenceStencilLayoutKHR*>(this) = rhs;
- }
-
- AttachmentReferenceStencilLayoutKHR& operator=( VkAttachmentReferenceStencilLayoutKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkAttachmentReferenceStencilLayoutKHR*>(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<vk::AttachmentReferenceStencilLayoutKHR const *>(&rhs);
return *this;
}
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<AttachmentReferenceStencilLayoutKHR>::value, "struct wrapper is not a standard layout!" );
Extent2D( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkExtent2D*>(this) = rhs;
+ *this = rhs;
}
Extent2D& operator=( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkExtent2D*>(this) = rhs;
+ *this = *reinterpret_cast<vk::Extent2D const *>(&rhs);
return *this;
}
SampleLocationEXT( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSampleLocationEXT*>(this) = rhs;
+ *this = rhs;
}
SampleLocationEXT& operator=( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSampleLocationEXT*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SampleLocationEXT const *>(&rhs);
return *this;
}
static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<SampleLocationEXT>::value, "struct wrapper is not a standard layout!" );
- 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<VkSampleLocationsInfoEXT*>(this) = rhs;
- }
-
- SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSampleLocationsInfoEXT*>(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<vk::SampleLocationsInfoEXT const *>(&rhs);
return *this;
}
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<SampleLocationsInfoEXT>::value, "struct wrapper is not a standard layout!" );
AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkAttachmentSampleLocationsEXT*>(this) = rhs;
+ *this = rhs;
}
AttachmentSampleLocationsEXT& operator=( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkAttachmentSampleLocationsEXT*>(this) = rhs;
+ *this = *reinterpret_cast<vk::AttachmentSampleLocationsEXT const *>(&rhs);
return *this;
}
static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<AttachmentSampleLocationsEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct BaseInStructure
- {
- protected:
- BaseInStructure() VULKAN_HPP_NOEXCEPT
- {}
-
- BaseInStructure( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBaseInStructure*>(this) = rhs;
- }
-
- BaseInStructure& operator=( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBaseInStructure*>(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<vk::BaseInStructure const *>(&rhs);
return *this;
}
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<BaseInStructure>::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<VkBaseOutStructure*>(this) = rhs;
- }
-
- BaseOutStructure& operator=( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBaseOutStructure*>(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<vk::BaseOutStructure const *>(&rhs);
return *this;
}
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<BaseOutStructure>::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<VkBindAccelerationStructureMemoryInfoNV*>(this) = rhs;
- }
-
- BindAccelerationStructureMemoryInfoNV& operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV*>(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<vk::BindAccelerationStructureMemoryInfoNV const *>(&rhs);
return *this;
}
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<BindAccelerationStructureMemoryInfoNV>::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<VkBindBufferMemoryDeviceGroupInfo*>(this) = rhs;
- }
-
- BindBufferMemoryDeviceGroupInfo& operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(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<vk::BindBufferMemoryDeviceGroupInfo const *>(&rhs);
return *this;
}
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<BindBufferMemoryDeviceGroupInfo>::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<VkBindBufferMemoryInfo*>(this) = rhs;
- }
-
- BindBufferMemoryInfo& operator=( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBindBufferMemoryInfo*>(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<vk::BindBufferMemoryInfo const *>(&rhs);
return *this;
}
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<BindBufferMemoryInfo>::value, "struct wrapper is not a standard layout!" );
Offset2D( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkOffset2D*>(this) = rhs;
+ *this = rhs;
}
Offset2D& operator=( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkOffset2D*>(this) = rhs;
+ *this = *reinterpret_cast<vk::Offset2D const *>(&rhs);
return *this;
}
Rect2D( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkRect2D*>(this) = rhs;
+ *this = rhs;
}
Rect2D& operator=( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkRect2D*>(this) = rhs;
+ *this = *reinterpret_cast<vk::Rect2D const *>(&rhs);
return *this;
}
static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<Rect2D>::value, "struct wrapper is not a standard layout!" );
- 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<VkBindImageMemoryDeviceGroupInfo*>(this) = rhs;
- }
-
- BindImageMemoryDeviceGroupInfo& operator=( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(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<vk::BindImageMemoryDeviceGroupInfo const *>(&rhs);
return *this;
}
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<BindImageMemoryDeviceGroupInfo>::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<VkBindImageMemoryInfo*>(this) = rhs;
- }
-
- BindImageMemoryInfo& operator=( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBindImageMemoryInfo*>(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<vk::BindImageMemoryInfo const *>(&rhs);
return *this;
}
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<BindImageMemoryInfo>::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<VkBindImageMemorySwapchainInfoKHR*>(this) = rhs;
- }
-
- BindImageMemorySwapchainInfoKHR& operator=( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(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<vk::BindImageMemorySwapchainInfoKHR const *>(&rhs);
return *this;
}
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<BindImageMemorySwapchainInfoKHR>::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<VkBindImagePlaneMemoryInfo*>(this) = rhs;
- }
-
- BindImagePlaneMemoryInfo& operator=( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBindImagePlaneMemoryInfo*>(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<vk::BindImagePlaneMemoryInfo const *>(&rhs);
return *this;
}
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<BindImagePlaneMemoryInfo>::value, "struct wrapper is not a standard layout!" );
SparseMemoryBind( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSparseMemoryBind*>(this) = rhs;
+ *this = rhs;
}
SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSparseMemoryBind*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SparseMemoryBind const *>(&rhs);
return *this;
}
SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSparseBufferMemoryBindInfo*>(this) = rhs;
+ *this = rhs;
}
SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSparseBufferMemoryBindInfo*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SparseBufferMemoryBindInfo const *>(&rhs);
return *this;
}
SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>(this) = rhs;
+ *this = rhs;
}
SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SparseImageOpaqueMemoryBindInfo const *>(&rhs);
return *this;
}
ImageSubresource( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkImageSubresource*>(this) = rhs;
+ *this = rhs;
}
ImageSubresource& operator=( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkImageSubresource*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ImageSubresource const *>(&rhs);
return *this;
}
Offset3D( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkOffset3D*>(this) = rhs;
+ *this = rhs;
}
Offset3D& operator=( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkOffset3D*>(this) = rhs;
+ *this = *reinterpret_cast<vk::Offset3D const *>(&rhs);
return *this;
}
Extent3D( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkExtent3D*>(this) = rhs;
+ *this = rhs;
}
Extent3D& operator=( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkExtent3D*>(this) = rhs;
+ *this = *reinterpret_cast<vk::Extent3D const *>(&rhs);
return *this;
}
SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSparseImageMemoryBind*>(this) = rhs;
+ *this = rhs;
}
SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSparseImageMemoryBind*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SparseImageMemoryBind const *>(&rhs);
return *this;
}
SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSparseImageMemoryBindInfo*>(this) = rhs;
+ *this = rhs;
}
SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSparseImageMemoryBindInfo*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SparseImageMemoryBindInfo const *>(&rhs);
return *this;
}
static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<SparseImageMemoryBindInfo>::value, "struct wrapper is not a standard layout!" );
- 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<VkBindSparseInfo*>(this) = rhs;
- }
-
- BindSparseInfo& operator=( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBindSparseInfo*>(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,
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<vk::BindSparseInfo const *>(&rhs);
return *this;
}
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<BindSparseInfo>::value, "struct wrapper is not a standard layout!" );
BufferCopy( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkBufferCopy*>(this) = rhs;
+ *this = rhs;
}
BufferCopy& operator=( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkBufferCopy*>(this) = rhs;
+ *this = *reinterpret_cast<vk::BufferCopy const *>(&rhs);
return *this;
}
static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<BufferCopy>::value, "struct wrapper is not a standard layout!" );
- 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<VkBufferCreateInfo*>(this) = rhs;
- }
-
- BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBufferCreateInfo*>(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,
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<vk::BufferCreateInfo const *>(&rhs);
return *this;
}
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<BufferCreateInfo>::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<VkBufferDeviceAddressCreateInfoEXT*>(this) = rhs;
- }
-
- BufferDeviceAddressCreateInfoEXT& operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(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<vk::BufferDeviceAddressCreateInfoEXT const *>(&rhs);
return *this;
}
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<BufferDeviceAddressCreateInfoEXT>::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<VkBufferDeviceAddressInfoEXT*>(this) = rhs;
- }
-
- BufferDeviceAddressInfoEXT& operator=( VkBufferDeviceAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBufferDeviceAddressInfoEXT*>(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<vk::BufferDeviceAddressInfoEXT const *>(&rhs);
return *this;
}
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<BufferDeviceAddressInfoEXT>::value, "struct wrapper is not a standard layout!" );
ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkImageSubresourceLayers*>(this) = rhs;
+ *this = rhs;
}
ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkImageSubresourceLayers*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ImageSubresourceLayers const *>(&rhs);
return *this;
}
BufferImageCopy( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkBufferImageCopy*>(this) = rhs;
+ *this = rhs;
}
BufferImageCopy& operator=( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkBufferImageCopy*>(this) = rhs;
+ *this = *reinterpret_cast<vk::BufferImageCopy const *>(&rhs);
return *this;
}
static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<BufferImageCopy>::value, "struct wrapper is not a standard layout!" );
- 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<VkBufferMemoryBarrier*>(this) = rhs;
- }
-
- BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBufferMemoryBarrier*>(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(),
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<vk::BufferMemoryBarrier const *>(&rhs);
return *this;
}
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<BufferMemoryBarrier>::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<VkBufferMemoryRequirementsInfo2*>(this) = rhs;
- }
-
- BufferMemoryRequirementsInfo2& operator=( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBufferMemoryRequirementsInfo2*>(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<vk::BufferMemoryRequirementsInfo2 const *>(&rhs);
return *this;
}
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<BufferMemoryRequirementsInfo2>::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<VkBufferViewCreateInfo*>(this) = rhs;
- }
-
- BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkBufferViewCreateInfo*>(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<vk::BufferViewCreateInfo const *>(&rhs);
return *this;
}
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<BufferViewCreateInfo>::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<VkCalibratedTimestampInfoEXT*>(this) = rhs;
- }
-
- CalibratedTimestampInfoEXT& operator=( VkCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkCalibratedTimestampInfoEXT*>(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<vk::CalibratedTimestampInfoEXT const *>(&rhs);
return *this;
}
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<CalibratedTimestampInfoEXT>::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<VkCheckpointDataNV*>(this) = rhs;
- }
-
- CheckpointDataNV& operator=( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkCheckpointDataNV*>(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<vk::CheckpointDataNV const *>(&rhs);
return *this;
}
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<CheckpointDataNV>::value, "struct wrapper is not a standard layout!" );
ClearDepthStencilValue( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkClearDepthStencilValue*>(this) = rhs;
+ *this = rhs;
}
ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkClearDepthStencilValue*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ClearDepthStencilValue const *>(&rhs);
return *this;
}
ClearAttachment( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkClearAttachment*>(this) = rhs;
+ *this = rhs;
}
ClearAttachment& operator=( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkClearAttachment*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ClearAttachment const *>(&rhs);
return *this;
}
ClearRect( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkClearRect*>(this) = rhs;
+ *this = rhs;
}
ClearRect& operator=( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkClearRect*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ClearRect const *>(&rhs);
return *this;
}
IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkIndirectCommandsTokenNVX*>(this) = rhs;
+ *this = rhs;
}
IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkIndirectCommandsTokenNVX*>(this) = rhs;
+ *this = *reinterpret_cast<vk::IndirectCommandsTokenNVX const *>(&rhs);
return *this;
}
static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<IndirectCommandsTokenNVX>::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<VkCmdProcessCommandsInfoNVX*>(this) = rhs;
- }
-
- CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkCmdProcessCommandsInfoNVX*>(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(),
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<vk::CmdProcessCommandsInfoNVX const *>(&rhs);
return *this;
}
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<CmdProcessCommandsInfoNVX>::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<VkCmdReserveSpaceForCommandsInfoNVX*>(this) = rhs;
- }
-
- CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX*>(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<vk::CmdReserveSpaceForCommandsInfoNVX const *>(&rhs);
return *this;
}
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<CmdReserveSpaceForCommandsInfoNVX>::value, "struct wrapper is not a standard layout!" );
CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkCoarseSampleLocationNV*>(this) = rhs;
+ *this = rhs;
}
CoarseSampleLocationNV& operator=( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkCoarseSampleLocationNV*>(this) = rhs;
+ *this = *reinterpret_cast<vk::CoarseSampleLocationNV const *>(&rhs);
return *this;
}
CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkCoarseSampleOrderCustomNV*>(this) = rhs;
+ *this = rhs;
}
CoarseSampleOrderCustomNV& operator=( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkCoarseSampleOrderCustomNV*>(this) = rhs;
+ *this = *reinterpret_cast<vk::CoarseSampleOrderCustomNV const *>(&rhs);
return *this;
}
static_assert( sizeof( CoarseSampleOrderCustomNV ) == sizeof( VkCoarseSampleOrderCustomNV ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<CoarseSampleOrderCustomNV>::value, "struct wrapper is not a standard layout!" );
- 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<VkCommandBufferAllocateInfo*>(this) = rhs;
- }
-
- CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkCommandBufferAllocateInfo*>(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<vk::CommandBufferAllocateInfo const *>(&rhs);
return *this;
}
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<CommandBufferAllocateInfo>::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<VkCommandBufferInheritanceInfo*>(this) = rhs;
- }
-
- CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkCommandBufferInheritanceInfo*>(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,
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<vk::CommandBufferInheritanceInfo const *>(&rhs);
return *this;
}
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<CommandBufferInheritanceInfo>::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<VkCommandBufferBeginInfo*>(this) = rhs;
- }
-
- CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkCommandBufferBeginInfo*>(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<vk::CommandBufferBeginInfo const *>(&rhs);
return *this;
}
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<CommandBufferBeginInfo>::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<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this) = rhs;
- }
-
- CommandBufferInheritanceConditionalRenderingInfoEXT& operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(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<vk::CommandBufferInheritanceConditionalRenderingInfoEXT const *>(&rhs);
return *this;
}
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<CommandBufferInheritanceConditionalRenderingInfoEXT>::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<VkCommandPoolCreateInfo*>(this) = rhs;
- }
-
- CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkCommandPoolCreateInfo*>(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<vk::CommandPoolCreateInfo const *>(&rhs);
return *this;
}
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<CommandPoolCreateInfo>::value, "struct wrapper is not a standard layout!" );
SpecializationMapEntry( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSpecializationMapEntry*>(this) = rhs;
+ *this = rhs;
}
SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSpecializationMapEntry*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SpecializationMapEntry const *>(&rhs);
return *this;
}
SpecializationInfo( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSpecializationInfo*>(this) = rhs;
+ *this = rhs;
}
SpecializationInfo& operator=( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSpecializationInfo*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SpecializationInfo const *>(&rhs);
return *this;
}
static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<SpecializationInfo>::value, "struct wrapper is not a standard layout!" );
- 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<VkPipelineShaderStageCreateInfo*>(this) = rhs;
- }
-
- PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineShaderStageCreateInfo*>(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<vk::PipelineShaderStageCreateInfo const *>(&rhs);
return *this;
}
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<PipelineShaderStageCreateInfo>::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<VkComputePipelineCreateInfo*>(this) = rhs;
- }
-
- ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkComputePipelineCreateInfo*>(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<vk::ComputePipelineCreateInfo const *>(&rhs);
return *this;
}
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<ComputePipelineCreateInfo>::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<VkConditionalRenderingBeginInfoEXT*>(this) = rhs;
- }
-
- ConditionalRenderingBeginInfoEXT& operator=( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>(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<vk::ConditionalRenderingBeginInfoEXT const *>(&rhs);
return *this;
}
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<ConditionalRenderingBeginInfoEXT>::value, "struct wrapper is not a standard layout!" );
ConformanceVersionKHR( VkConformanceVersionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkConformanceVersionKHR*>(this) = rhs;
+ *this = rhs;
}
ConformanceVersionKHR& operator=( VkConformanceVersionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkConformanceVersionKHR*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ConformanceVersionKHR const *>(&rhs);
return *this;
}
static_assert( sizeof( ConformanceVersionKHR ) == sizeof( VkConformanceVersionKHR ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<ConformanceVersionKHR>::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<VkCooperativeMatrixPropertiesNV*>(this) = rhs;
- }
-
- CooperativeMatrixPropertiesNV& operator=( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkCooperativeMatrixPropertiesNV*>(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,
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<vk::CooperativeMatrixPropertiesNV const *>(&rhs);
return *this;
}
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<CooperativeMatrixPropertiesNV>::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<VkCopyDescriptorSet*>(this) = rhs;
- }
-
- CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkCopyDescriptorSet*>(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,
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<vk::CopyDescriptorSet const *>(&rhs);
return *this;
}
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<CopyDescriptorSet>::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<VkD3D12FenceSubmitInfoKHR*>(this) = rhs;
- }
-
- D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(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<vk::D3D12FenceSubmitInfoKHR const *>(&rhs);
return *this;
}
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<D3D12FenceSubmitInfoKHR>::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<float,4> const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
- : pMarkerName( pMarkerName_ )
- , color{}
- {
- vk::ConstExpressionArrayCopy<float,4,4>::copy( color, color_ );
- }
-
- DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>(this) = rhs;
- }
-
- DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>(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<float,4> const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
- : layout::DebugMarkerMarkerInfoEXT( pMarkerName_, color_ )
- {}
+ : pMarkerName( pMarkerName_ )
+ , color{}
+ {
+ vk::ConstExpressionArrayCopy<float,4,4>::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<vk::DebugMarkerMarkerInfoEXT const *>(&rhs);
return *this;
}
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<DebugMarkerMarkerInfoEXT>::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<VkDebugMarkerObjectNameInfoEXT*>(this) = rhs;
- }
-
- DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>(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<vk::DebugMarkerObjectNameInfoEXT const *>(&rhs);
return *this;
}
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<DebugMarkerObjectNameInfoEXT>::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<VkDebugMarkerObjectTagInfoEXT*>(this) = rhs;
- }
-
- DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>(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<vk::DebugMarkerObjectTagInfoEXT const *>(&rhs);
return *this;
}
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<DebugMarkerObjectTagInfoEXT>::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<VkDebugReportCallbackCreateInfoEXT*>(this) = rhs;
- }
-
- DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(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<vk::DebugReportCallbackCreateInfoEXT const *>(&rhs);
return *this;
}
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<DebugReportCallbackCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct DebugUtilsLabelEXT
- {
- protected:
- VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( const char* pLabelName_ = nullptr,
- std::array<float,4> const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
- : pLabelName( pLabelName_ )
- , color{}
- {
- vk::ConstExpressionArrayCopy<float,4,4>::copy( color, color_ );
- }
-
- DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDebugUtilsLabelEXT*>(this) = rhs;
- }
-
- DebugUtilsLabelEXT& operator=( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDebugUtilsLabelEXT*>(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<float,4> const& color_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
- : layout::DebugUtilsLabelEXT( pLabelName_, color_ )
- {}
+ : pLabelName( pLabelName_ )
+ , color{}
+ {
+ vk::ConstExpressionArrayCopy<float,4,4>::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<vk::DebugUtilsLabelEXT const *>(&rhs);
return *this;
}
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<DebugUtilsLabelEXT>::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<VkDebugUtilsObjectNameInfoEXT*>(this) = rhs;
- }
-
- DebugUtilsObjectNameInfoEXT& operator=( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(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<vk::DebugUtilsObjectNameInfoEXT const *>(&rhs);
return *this;
}
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<DebugUtilsObjectNameInfoEXT>::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<VkDebugUtilsMessengerCallbackDataEXT*>(this) = rhs;
- }
-
- DebugUtilsMessengerCallbackDataEXT& operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>(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,
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<vk::DebugUtilsMessengerCallbackDataEXT const *>(&rhs);
return *this;
}
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<DebugUtilsMessengerCallbackDataEXT>::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<VkDebugUtilsMessengerCreateInfoEXT*>(this) = rhs;
- }
-
- DebugUtilsMessengerCreateInfoEXT& operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(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<vk::DebugUtilsMessengerCreateInfoEXT const *>(&rhs);
return *this;
}
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<DebugUtilsMessengerCreateInfoEXT>::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<VkDebugUtilsObjectTagInfoEXT*>(this) = rhs;
- }
-
- DebugUtilsObjectTagInfoEXT& operator=( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>(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<vk::DebugUtilsObjectTagInfoEXT const *>(&rhs);
return *this;
}
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<DebugUtilsObjectTagInfoEXT>::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<VkDedicatedAllocationBufferCreateInfoNV*>(this) = rhs;
- }
-
- DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(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<vk::DedicatedAllocationBufferCreateInfoNV const *>(&rhs);
return *this;
}
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<DedicatedAllocationBufferCreateInfoNV>::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<VkDedicatedAllocationImageCreateInfoNV*>(this) = rhs;
- }
-
- DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(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<vk::DedicatedAllocationImageCreateInfoNV const *>(&rhs);
return *this;
}
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<DedicatedAllocationImageCreateInfoNV>::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<VkDedicatedAllocationMemoryAllocateInfoNV*>(this) = rhs;
- }
-
- DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(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<vk::DedicatedAllocationMemoryAllocateInfoNV const *>(&rhs);
return *this;
}
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<DedicatedAllocationMemoryAllocateInfoNV>::value, "struct wrapper is not a standard layout!" );
DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDescriptorBufferInfo*>(this) = rhs;
+ *this = rhs;
}
DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDescriptorBufferInfo*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DescriptorBufferInfo const *>(&rhs);
return *this;
}
DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDescriptorImageInfo*>(this) = rhs;
+ *this = rhs;
}
DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDescriptorImageInfo*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DescriptorImageInfo const *>(&rhs);
return *this;
}
DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDescriptorPoolSize*>(this) = rhs;
+ *this = rhs;
}
DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDescriptorPoolSize*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DescriptorPoolSize const *>(&rhs);
return *this;
}
static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<DescriptorPoolSize>::value, "struct wrapper is not a standard layout!" );
- 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<VkDescriptorPoolCreateInfo*>(this) = rhs;
- }
-
- DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDescriptorPoolCreateInfo*>(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<vk::DescriptorPoolCreateInfo const *>(&rhs);
return *this;
}
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<DescriptorPoolCreateInfo>::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<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this) = rhs;
- }
-
- DescriptorPoolInlineUniformBlockCreateInfoEXT& operator=( VkDescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(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<vk::DescriptorPoolInlineUniformBlockCreateInfoEXT const *>(&rhs);
return *this;
}
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<DescriptorPoolInlineUniformBlockCreateInfoEXT>::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<VkDescriptorSetAllocateInfo*>(this) = rhs;
- }
-
- DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDescriptorSetAllocateInfo*>(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<vk::DescriptorSetAllocateInfo const *>(&rhs);
return *this;
}
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<DescriptorSetAllocateInfo>::value, "struct wrapper is not a standard layout!" );
DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDescriptorSetLayoutBinding*>(this) = rhs;
+ *this = rhs;
}
DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDescriptorSetLayoutBinding*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DescriptorSetLayoutBinding const *>(&rhs);
return *this;
}
static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<DescriptorSetLayoutBinding>::value, "struct wrapper is not a standard layout!" );
- 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<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this) = rhs;
- }
-
- DescriptorSetLayoutBindingFlagsCreateInfoEXT& operator=( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(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<vk::DescriptorSetLayoutBindingFlagsCreateInfoEXT const *>(&rhs);
return *this;
}
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<DescriptorSetLayoutBindingFlagsCreateInfoEXT>::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<VkDescriptorSetLayoutCreateInfo*>(this) = rhs;
- }
-
- DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>(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<vk::DescriptorSetLayoutCreateInfo const *>(&rhs);
return *this;
}
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<DescriptorSetLayoutCreateInfo>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct DescriptorSetLayoutSupport
- {
- protected:
- DescriptorSetLayoutSupport() VULKAN_HPP_NOEXCEPT
- {}
-
- DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDescriptorSetLayoutSupport*>(this) = rhs;
- }
-
- DescriptorSetLayoutSupport& operator=( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDescriptorSetLayoutSupport*>(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
+ struct 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<vk::DescriptorSetLayoutSupport const *>(&rhs);
return *this;
}
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<DescriptorSetLayoutSupport>::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<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this) = rhs;
- }
-
- DescriptorSetVariableDescriptorCountAllocateInfoEXT& operator=( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(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<vk::DescriptorSetVariableDescriptorCountAllocateInfoEXT const *>(&rhs);
return *this;
}
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<DescriptorSetVariableDescriptorCountAllocateInfoEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct DescriptorSetVariableDescriptorCountLayoutSupportEXT
- {
- protected:
- DescriptorSetVariableDescriptorCountLayoutSupportEXT() VULKAN_HPP_NOEXCEPT
- {}
-
- DescriptorSetVariableDescriptorCountLayoutSupportEXT( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(this) = rhs;
- }
-
- DescriptorSetVariableDescriptorCountLayoutSupportEXT& operator=( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(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
+ struct 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<vk::DescriptorSetVariableDescriptorCountLayoutSupportEXT const *>(&rhs);
return *this;
}
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<DescriptorSetVariableDescriptorCountLayoutSupportEXT>::value, "struct wrapper is not a standard layout!" );
DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>(this) = rhs;
+ *this = rhs;
}
DescriptorUpdateTemplateEntry& operator=( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DescriptorUpdateTemplateEntry const *>(&rhs);
return *this;
}
static_assert( sizeof( DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<DescriptorUpdateTemplateEntry>::value, "struct wrapper is not a standard layout!" );
- 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<VkDescriptorUpdateTemplateCreateInfo*>(this) = rhs;
- }
-
- DescriptorUpdateTemplateCreateInfo& operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>(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,
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<vk::DescriptorUpdateTemplateCreateInfo const *>(&rhs);
return *this;
}
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<DescriptorUpdateTemplateCreateInfo>::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<VkDeviceQueueCreateInfo*>(this) = rhs;
- }
-
- DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceQueueCreateInfo*>(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<vk::DeviceQueueCreateInfo const *>(&rhs);
return *this;
}
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<DeviceQueueCreateInfo>::value, "struct wrapper is not a standard layout!" );
PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPhysicalDeviceFeatures*>(this) = rhs;
+ *this = rhs;
}
PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPhysicalDeviceFeatures*>(this) = rhs;
+ *this = *reinterpret_cast<vk::PhysicalDeviceFeatures const *>(&rhs);
return *this;
}
static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PhysicalDeviceFeatures>::value, "struct wrapper is not a standard layout!" );
- 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<VkDeviceCreateInfo*>(this) = rhs;
- }
-
- DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceCreateInfo*>(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,
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<vk::DeviceCreateInfo const *>(&rhs);
return *this;
}
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<DeviceCreateInfo>::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<VkDeviceEventInfoEXT*>(this) = rhs;
- }
-
- DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceEventInfoEXT*>(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<vk::DeviceEventInfoEXT const *>(&rhs);
return *this;
}
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<DeviceEventInfoEXT>::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<VkDeviceGeneratedCommandsFeaturesNVX*>(this) = rhs;
- }
-
- DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>(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<vk::DeviceGeneratedCommandsFeaturesNVX const *>(&rhs);
return *this;
}
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<DeviceGeneratedCommandsFeaturesNVX>::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<VkDeviceGeneratedCommandsLimitsNVX*>(this) = rhs;
- }
-
- DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>(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<vk::DeviceGeneratedCommandsLimitsNVX const *>(&rhs);
return *this;
}
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<DeviceGeneratedCommandsLimitsNVX>::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<VkDeviceGroupBindSparseInfo*>(this) = rhs;
- }
-
- DeviceGroupBindSparseInfo& operator=( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceGroupBindSparseInfo*>(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<vk::DeviceGroupBindSparseInfo const *>(&rhs);
return *this;
}
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<DeviceGroupBindSparseInfo>::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<VkDeviceGroupCommandBufferBeginInfo*>(this) = rhs;
- }
-
- DeviceGroupCommandBufferBeginInfo& operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(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<vk::DeviceGroupCommandBufferBeginInfo const *>(&rhs);
return *this;
}
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<DeviceGroupCommandBufferBeginInfo>::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<VkDeviceGroupDeviceCreateInfo*>(this) = rhs;
- }
-
- DeviceGroupDeviceCreateInfo& operator=( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(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<vk::DeviceGroupDeviceCreateInfo const *>(&rhs);
return *this;
}
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<DeviceGroupDeviceCreateInfo>::value, "struct wrapper is not a standard layout!" );
- namespace layout
+ struct DeviceGroupPresentCapabilitiesKHR
{
- struct DeviceGroupPresentCapabilitiesKHR
+ DeviceGroupPresentCapabilitiesKHR( std::array<uint32_t,VK_MAX_DEVICE_GROUP_SIZE> const& presentMask_ = { { 0 } },
+ vk::DeviceGroupPresentModeFlagsKHR modes_ = vk::DeviceGroupPresentModeFlagsKHR() ) VULKAN_HPP_NOEXCEPT
+ : presentMask{}
+ , modes( modes_ )
{
- protected:
- DeviceGroupPresentCapabilitiesKHR() VULKAN_HPP_NOEXCEPT
- {}
-
- DeviceGroupPresentCapabilitiesKHR( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(this) = rhs;
- }
-
- DeviceGroupPresentCapabilitiesKHR& operator=( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(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!" );
- }
+ vk::ConstExpressionArrayCopy<uint32_t,VK_MAX_DEVICE_GROUP_SIZE,VK_MAX_DEVICE_GROUP_SIZE>::copy( presentMask, presentMask_ );
+ }
- 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<vk::DeviceGroupPresentCapabilitiesKHR const *>(&rhs);
return *this;
}
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<DeviceGroupPresentCapabilitiesKHR>::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<VkDeviceGroupPresentInfoKHR*>(this) = rhs;
- }
-
- DeviceGroupPresentInfoKHR& operator=( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(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<vk::DeviceGroupPresentInfoKHR const *>(&rhs);
return *this;
}
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<DeviceGroupPresentInfoKHR>::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<VkDeviceGroupRenderPassBeginInfo*>(this) = rhs;
- }
-
- DeviceGroupRenderPassBeginInfo& operator=( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(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<vk::DeviceGroupRenderPassBeginInfo const *>(&rhs);
return *this;
}
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<DeviceGroupRenderPassBeginInfo>::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<VkDeviceGroupSubmitInfo*>(this) = rhs;
- }
-
- DeviceGroupSubmitInfo& operator=( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceGroupSubmitInfo*>(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,
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<vk::DeviceGroupSubmitInfo const *>(&rhs);
return *this;
}
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<DeviceGroupSubmitInfo>::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<VkDeviceGroupSwapchainCreateInfoKHR*>(this) = rhs;
- }
-
- DeviceGroupSwapchainCreateInfoKHR& operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(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<vk::DeviceGroupSwapchainCreateInfoKHR const *>(&rhs);
return *this;
}
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<DeviceGroupSwapchainCreateInfoKHR>::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<VkDeviceMemoryOverallocationCreateInfoAMD*>(this) = rhs;
- }
-
- DeviceMemoryOverallocationCreateInfoAMD& operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(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<vk::DeviceMemoryOverallocationCreateInfoAMD const *>(&rhs);
return *this;
}
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<DeviceMemoryOverallocationCreateInfoAMD>::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<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this) = rhs;
- }
-
- DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(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<vk::DeviceQueueGlobalPriorityCreateInfoEXT const *>(&rhs);
return *this;
}
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<DeviceQueueGlobalPriorityCreateInfoEXT>::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<VkDeviceQueueInfo2*>(this) = rhs;
- }
-
- DeviceQueueInfo2& operator=( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDeviceQueueInfo2*>(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<vk::DeviceQueueInfo2 const *>(&rhs);
return *this;
}
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<DeviceQueueInfo2>::value, "struct wrapper is not a standard layout!" );
DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDispatchIndirectCommand*>(this) = rhs;
+ *this = rhs;
}
DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDispatchIndirectCommand*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DispatchIndirectCommand const *>(&rhs);
return *this;
}
static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<DispatchIndirectCommand>::value, "struct wrapper is not a standard layout!" );
- 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<VkDisplayEventInfoEXT*>(this) = rhs;
- }
-
- DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplayEventInfoEXT*>(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<vk::DisplayEventInfoEXT const *>(&rhs);
return *this;
}
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<DisplayEventInfoEXT>::value, "struct wrapper is not a standard layout!" );
DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDisplayModeParametersKHR*>(this) = rhs;
+ *this = rhs;
}
DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDisplayModeParametersKHR*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DisplayModeParametersKHR const *>(&rhs);
return *this;
}
static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<DisplayModeParametersKHR>::value, "struct wrapper is not a standard layout!" );
- 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<VkDisplayModeCreateInfoKHR*>(this) = rhs;
- }
-
- DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplayModeCreateInfoKHR*>(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<vk::DisplayModeCreateInfoKHR const *>(&rhs);
return *this;
}
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<DisplayModeCreateInfoKHR>::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<VkDisplayModePropertiesKHR*>(this) = rhs;
+ *this = rhs;
}
DisplayModePropertiesKHR& operator=( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDisplayModePropertiesKHR*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DisplayModePropertiesKHR const *>(&rhs);
return *this;
}
static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<DisplayModePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
- namespace layout
+ struct DisplayModeProperties2KHR
{
- struct DisplayModeProperties2KHR
- {
- protected:
- DisplayModeProperties2KHR() VULKAN_HPP_NOEXCEPT
- {}
-
- DisplayModeProperties2KHR( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplayModeProperties2KHR*>(this) = rhs;
- }
-
- DisplayModeProperties2KHR& operator=( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplayModeProperties2KHR*>(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<vk::DisplayModeProperties2KHR const *>(&rhs);
return *this;
}
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<DisplayModeProperties2KHR>::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<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(this) = rhs;
- }
-
- DisplayNativeHdrSurfaceCapabilitiesAMD& operator=( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(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<vk::DisplayNativeHdrSurfaceCapabilitiesAMD const *>(&rhs);
return *this;
}
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<DisplayNativeHdrSurfaceCapabilitiesAMD>::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<VkDisplayPlaneCapabilitiesKHR*>(this) = rhs;
+ *this = rhs;
}
DisplayPlaneCapabilitiesKHR& operator=( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DisplayPlaneCapabilitiesKHR const *>(&rhs);
return *this;
}
static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<DisplayPlaneCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct DisplayPlaneCapabilities2KHR
- {
- protected:
- DisplayPlaneCapabilities2KHR() VULKAN_HPP_NOEXCEPT
- {}
-
- DisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>(this) = rhs;
- }
-
- DisplayPlaneCapabilities2KHR& operator=( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>(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
+ struct 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<vk::DisplayPlaneCapabilities2KHR const *>(&rhs);
return *this;
}
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<DisplayPlaneCapabilities2KHR>::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<VkDisplayPlaneInfo2KHR*>(this) = rhs;
- }
-
- DisplayPlaneInfo2KHR& operator=( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplayPlaneInfo2KHR*>(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<vk::DisplayPlaneInfo2KHR const *>(&rhs);
return *this;
}
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<DisplayPlaneInfo2KHR>::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<VkDisplayPlanePropertiesKHR*>(this) = rhs;
+ *this = rhs;
}
DisplayPlanePropertiesKHR& operator=( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDisplayPlanePropertiesKHR*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DisplayPlanePropertiesKHR const *>(&rhs);
return *this;
}
static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<DisplayPlanePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
- namespace layout
+ struct DisplayPlaneProperties2KHR
{
- struct DisplayPlaneProperties2KHR
- {
- protected:
- DisplayPlaneProperties2KHR() VULKAN_HPP_NOEXCEPT
- {}
-
- DisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplayPlaneProperties2KHR*>(this) = rhs;
- }
-
- DisplayPlaneProperties2KHR& operator=( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplayPlaneProperties2KHR*>(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<vk::DisplayPlaneProperties2KHR const *>(&rhs);
return *this;
}
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<DisplayPlaneProperties2KHR>::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<VkDisplayPowerInfoEXT*>(this) = rhs;
- }
-
- DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplayPowerInfoEXT*>(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<vk::DisplayPowerInfoEXT const *>(&rhs);
return *this;
}
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<DisplayPowerInfoEXT>::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<VkDisplayPresentInfoKHR*>(this) = rhs;
- }
-
- DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplayPresentInfoKHR*>(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<vk::DisplayPresentInfoKHR const *>(&rhs);
return *this;
}
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<DisplayPresentInfoKHR>::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<VkDisplayPropertiesKHR*>(this) = rhs;
+ *this = rhs;
}
DisplayPropertiesKHR& operator=( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDisplayPropertiesKHR*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DisplayPropertiesKHR const *>(&rhs);
return *this;
}
static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<DisplayPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct DisplayProperties2KHR
- {
- protected:
- DisplayProperties2KHR() VULKAN_HPP_NOEXCEPT
- {}
-
- DisplayProperties2KHR( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplayProperties2KHR*>(this) = rhs;
- }
-
- DisplayProperties2KHR& operator=( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplayProperties2KHR*>(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
+ struct 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<vk::DisplayProperties2KHR const *>(&rhs);
return *this;
}
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<DisplayProperties2KHR>::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<VkDisplaySurfaceCreateInfoKHR*>(this) = rhs;
- }
-
- DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>(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(),
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<vk::DisplaySurfaceCreateInfoKHR const *>(&rhs);
return *this;
}
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<DisplaySurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDrawIndexedIndirectCommand*>(this) = rhs;
+ *this = rhs;
}
DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDrawIndexedIndirectCommand*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DrawIndexedIndirectCommand const *>(&rhs);
return *this;
}
DrawIndirectCommand( VkDrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDrawIndirectCommand*>(this) = rhs;
+ *this = rhs;
}
DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDrawIndirectCommand*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DrawIndirectCommand const *>(&rhs);
return *this;
}
DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV*>(this) = rhs;
+ *this = rhs;
}
DrawMeshTasksIndirectCommandNV& operator=( VkDrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DrawMeshTasksIndirectCommandNV const *>(&rhs);
return *this;
}
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<VkDrmFormatModifierPropertiesEXT*>(this) = rhs;
+ *this = rhs;
}
DrmFormatModifierPropertiesEXT& operator=( VkDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkDrmFormatModifierPropertiesEXT*>(this) = rhs;
+ *this = *reinterpret_cast<vk::DrmFormatModifierPropertiesEXT const *>(&rhs);
return *this;
}
static_assert( sizeof( DrmFormatModifierPropertiesEXT ) == sizeof( VkDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<DrmFormatModifierPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct DrmFormatModifierPropertiesListEXT
- {
- protected:
- DrmFormatModifierPropertiesListEXT() VULKAN_HPP_NOEXCEPT
- {}
-
- DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(this) = rhs;
- }
-
- DrmFormatModifierPropertiesListEXT& operator=( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(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
+ struct 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<vk::DrmFormatModifierPropertiesListEXT const *>(&rhs);
return *this;
}
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<DrmFormatModifierPropertiesListEXT>::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<VkEventCreateInfo*>(this) = rhs;
- }
-
- EventCreateInfo& operator=( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkEventCreateInfo*>(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<vk::EventCreateInfo const *>(&rhs);
return *this;
}
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<EventCreateInfo>::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<VkExportFenceCreateInfo*>(this) = rhs;
- }
-
- ExportFenceCreateInfo& operator=( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExportFenceCreateInfo*>(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<vk::ExportFenceCreateInfo const *>(&rhs);
return *this;
}
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<ExportFenceCreateInfo>::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<VkExportFenceWin32HandleInfoKHR*>(this) = rhs;
- }
-
- ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(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<vk::ExportFenceWin32HandleInfoKHR const *>(&rhs);
return *this;
}
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<ExportFenceWin32HandleInfoKHR>::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<VkExportMemoryAllocateInfo*>(this) = rhs;
- }
-
- ExportMemoryAllocateInfo& operator=( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExportMemoryAllocateInfo*>(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<vk::ExportMemoryAllocateInfo const *>(&rhs);
return *this;
}
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<ExportMemoryAllocateInfo>::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<VkExportMemoryAllocateInfoNV*>(this) = rhs;
- }
-
- ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExportMemoryAllocateInfoNV*>(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<vk::ExportMemoryAllocateInfoNV const *>(&rhs);
return *this;
}
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<ExportMemoryAllocateInfoNV>::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<VkExportMemoryWin32HandleInfoKHR*>(this) = rhs;
- }
-
- ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(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<vk::ExportMemoryWin32HandleInfoKHR const *>(&rhs);
return *this;
}
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<ExportMemoryWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
#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<VkExportMemoryWin32HandleInfoNV*>(this) = rhs;
- }
-
- ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(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<vk::ExportMemoryWin32HandleInfoNV const *>(&rhs);
return *this;
}
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<ExportMemoryWin32HandleInfoNV>::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<VkExportSemaphoreCreateInfo*>(this) = rhs;
- }
-
- ExportSemaphoreCreateInfo& operator=( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExportSemaphoreCreateInfo*>(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<vk::ExportSemaphoreCreateInfo const *>(&rhs);
return *this;
}
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<ExportSemaphoreCreateInfo>::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<VkExportSemaphoreWin32HandleInfoKHR*>(this) = rhs;
- }
-
- ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(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<vk::ExportSemaphoreWin32HandleInfoKHR const *>(&rhs);
return *this;
}
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<ExportSemaphoreWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
struct ExtensionProperties
{
- ExtensionProperties() VULKAN_HPP_NOEXCEPT
- {}
+ ExtensionProperties( std::array<char,VK_MAX_EXTENSION_NAME_SIZE> const& extensionName_ = { { 0 } },
+ uint32_t specVersion_ = 0 ) VULKAN_HPP_NOEXCEPT
+ : extensionName{}
+ , specVersion( specVersion_ )
+ {
+ vk::ConstExpressionArrayCopy<char,VK_MAX_EXTENSION_NAME_SIZE,VK_MAX_EXTENSION_NAME_SIZE>::copy( extensionName, extensionName_ );
+ }
ExtensionProperties( VkExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkExtensionProperties*>(this) = rhs;
+ *this = rhs;
}
ExtensionProperties& operator=( VkExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkExtensionProperties*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ExtensionProperties const *>(&rhs);
return *this;
}
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<VkExternalMemoryProperties*>(this) = rhs;
+ *this = rhs;
}
ExternalMemoryProperties& operator=( VkExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkExternalMemoryProperties*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ExternalMemoryProperties const *>(&rhs);
return *this;
}
static_assert( sizeof( ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<ExternalMemoryProperties>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct ExternalBufferProperties
- {
- protected:
- ExternalBufferProperties() VULKAN_HPP_NOEXCEPT
- {}
-
- ExternalBufferProperties( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExternalBufferProperties*>(this) = rhs;
- }
-
- ExternalBufferProperties& operator=( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExternalBufferProperties*>(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
+ struct 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<vk::ExternalBufferProperties const *>(&rhs);
return *this;
}
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<ExternalBufferProperties>::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<VkExternalFenceProperties*>(this) = rhs;
- }
-
- ExternalFenceProperties& operator=( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExternalFenceProperties*>(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<vk::ExternalFenceProperties const *>(&rhs);
return *this;
}
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<ExternalFenceProperties>::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<VkExternalFormatANDROID*>(this) = rhs;
- }
-
- ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExternalFormatANDROID*>(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<vk::ExternalFormatANDROID const *>(&rhs);
return *this;
}
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<ExternalFormatANDROID>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
- namespace layout
- {
- struct ExternalImageFormatProperties
- {
- protected:
- ExternalImageFormatProperties() VULKAN_HPP_NOEXCEPT
- {}
-
- ExternalImageFormatProperties( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExternalImageFormatProperties*>(this) = rhs;
- }
-
- ExternalImageFormatProperties& operator=( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExternalImageFormatProperties*>(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
+ struct 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<vk::ExternalImageFormatProperties const *>(&rhs);
return *this;
}
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<ExternalImageFormatProperties>::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<VkImageFormatProperties*>(this) = rhs;
+ *this = rhs;
}
ImageFormatProperties& operator=( VkImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkImageFormatProperties*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ImageFormatProperties const *>(&rhs);
return *this;
}
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<VkExternalImageFormatPropertiesNV*>(this) = rhs;
+ *this = rhs;
}
ExternalImageFormatPropertiesNV& operator=( VkExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkExternalImageFormatPropertiesNV*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ExternalImageFormatPropertiesNV const *>(&rhs);
return *this;
}
static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<ExternalImageFormatPropertiesNV>::value, "struct wrapper is not a standard layout!" );
- 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<VkExternalMemoryBufferCreateInfo*>(this) = rhs;
- }
-
- ExternalMemoryBufferCreateInfo& operator=( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(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<vk::ExternalMemoryBufferCreateInfo const *>(&rhs);
return *this;
}
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<ExternalMemoryBufferCreateInfo>::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<VkExternalMemoryImageCreateInfo*>(this) = rhs;
- }
-
- ExternalMemoryImageCreateInfo& operator=( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExternalMemoryImageCreateInfo*>(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<vk::ExternalMemoryImageCreateInfo const *>(&rhs);
return *this;
}
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<ExternalMemoryImageCreateInfo>::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<VkExternalMemoryImageCreateInfoNV*>(this) = rhs;
- }
-
- ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(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<vk::ExternalMemoryImageCreateInfoNV const *>(&rhs);
return *this;
}
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<ExternalMemoryImageCreateInfoNV>::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<VkExternalSemaphoreProperties*>(this) = rhs;
- }
-
- ExternalSemaphoreProperties& operator=( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkExternalSemaphoreProperties*>(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<vk::ExternalSemaphoreProperties const *>(&rhs);
return *this;
}
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<ExternalSemaphoreProperties>::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<VkFenceCreateInfo*>(this) = rhs;
- }
-
- FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkFenceCreateInfo*>(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<vk::FenceCreateInfo const *>(&rhs);
return *this;
}
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<FenceCreateInfo>::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<VkFenceGetFdInfoKHR*>(this) = rhs;
- }
-
- FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkFenceGetFdInfoKHR*>(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<vk::FenceGetFdInfoKHR const *>(&rhs);
return *this;
}
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<FenceGetFdInfoKHR>::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<VkFenceGetWin32HandleInfoKHR*>(this) = rhs;
- }
-
- FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>(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<vk::FenceGetWin32HandleInfoKHR const *>(&rhs);
return *this;
}
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<FenceGetWin32HandleInfoKHR>::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<VkFilterCubicImageViewImageFormatPropertiesEXT*>(this) = rhs;
- }
-
- FilterCubicImageViewImageFormatPropertiesEXT& operator=( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(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<vk::FilterCubicImageViewImageFormatPropertiesEXT const *>(&rhs);
return *this;
}
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<FilterCubicImageViewImageFormatPropertiesEXT>::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<VkFormatProperties*>(this) = rhs;
+ *this = rhs;
}
FormatProperties& operator=( VkFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkFormatProperties*>(this) = rhs;
+ *this = *reinterpret_cast<vk::FormatProperties const *>(&rhs);
return *this;
}
static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<FormatProperties>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct FormatProperties2
- {
- protected:
- FormatProperties2() VULKAN_HPP_NOEXCEPT
- {}
-
- FormatProperties2( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkFormatProperties2*>(this) = rhs;
- }
-
- FormatProperties2& operator=( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkFormatProperties2*>(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
+ struct 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<vk::FormatProperties2 const *>(&rhs);
return *this;
}
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<FormatProperties2>::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<VkFramebufferAttachmentImageInfoKHR*>(this) = rhs;
- }
-
- FramebufferAttachmentImageInfoKHR& operator=( VkFramebufferAttachmentImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkFramebufferAttachmentImageInfoKHR*>(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(),
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<vk::FramebufferAttachmentImageInfoKHR const *>(&rhs);
return *this;
}
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<FramebufferAttachmentImageInfoKHR>::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<VkFramebufferAttachmentsCreateInfoKHR*>(this) = rhs;
- }
-
- FramebufferAttachmentsCreateInfoKHR& operator=( VkFramebufferAttachmentsCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkFramebufferAttachmentsCreateInfoKHR*>(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<vk::FramebufferAttachmentsCreateInfoKHR const *>(&rhs);
return *this;
}
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<FramebufferAttachmentsCreateInfoKHR>::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<VkFramebufferCreateInfo*>(this) = rhs;
- }
-
- FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkFramebufferCreateInfo*>(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(),
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<vk::FramebufferCreateInfo const *>(&rhs);
return *this;
}
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<FramebufferCreateInfo>::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<VkFramebufferMixedSamplesCombinationNV*>(this) = rhs;
- }
-
- FramebufferMixedSamplesCombinationNV& operator=( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkFramebufferMixedSamplesCombinationNV*>(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<vk::FramebufferMixedSamplesCombinationNV const *>(&rhs);
return *this;
}
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<FramebufferMixedSamplesCombinationNV>::value, "struct wrapper is not a standard layout!" );
VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkVertexInputBindingDescription*>(this) = rhs;
+ *this = rhs;
}
VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkVertexInputBindingDescription*>(this) = rhs;
+ *this = *reinterpret_cast<vk::VertexInputBindingDescription const *>(&rhs);
return *this;
}
VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkVertexInputAttributeDescription*>(this) = rhs;
+ *this = rhs;
}
VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkVertexInputAttributeDescription*>(this) = rhs;
+ *this = *reinterpret_cast<vk::VertexInputAttributeDescription const *>(&rhs);
return *this;
}
static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<VertexInputAttributeDescription>::value, "struct wrapper is not a standard layout!" );
- 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<VkPipelineVertexInputStateCreateInfo*>(this) = rhs;
- }
-
- PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(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<vk::PipelineVertexInputStateCreateInfo const *>(&rhs);
return *this;
}
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<PipelineVertexInputStateCreateInfo>::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<VkPipelineInputAssemblyStateCreateInfo*>(this) = rhs;
- }
-
- PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>(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<vk::PipelineInputAssemblyStateCreateInfo const *>(&rhs);
return *this;
}
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<PipelineInputAssemblyStateCreateInfo>::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<VkPipelineTessellationStateCreateInfo*>(this) = rhs;
- }
-
- PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(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<vk::PipelineTessellationStateCreateInfo const *>(&rhs);
return *this;
}
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<PipelineTessellationStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
Viewport( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkViewport*>(this) = rhs;
+ *this = rhs;
}
Viewport& operator=( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkViewport*>(this) = rhs;
+ *this = *reinterpret_cast<vk::Viewport const *>(&rhs);
return *this;
}
static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<Viewport>::value, "struct wrapper is not a standard layout!" );
- 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<VkPipelineViewportStateCreateInfo*>(this) = rhs;
- }
-
- PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineViewportStateCreateInfo*>(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<vk::PipelineViewportStateCreateInfo const *>(&rhs);
return *this;
}
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<PipelineViewportStateCreateInfo>::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<VkPipelineRasterizationStateCreateInfo*>(this) = rhs;
- }
-
- PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>(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,
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<vk::PipelineRasterizationStateCreateInfo const *>(&rhs);
return *this;
}
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<PipelineRasterizationStateCreateInfo>::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<VkPipelineMultisampleStateCreateInfo*>(this) = rhs;
- }
-
- PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(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,
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<vk::PipelineMultisampleStateCreateInfo const *>(&rhs);
return *this;
}
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<PipelineMultisampleStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
StencilOpState( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkStencilOpState*>(this) = rhs;
+ *this = rhs;
}
StencilOpState& operator=( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkStencilOpState*>(this) = rhs;
+ *this = *reinterpret_cast<vk::StencilOpState const *>(&rhs);
return *this;
}
static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<StencilOpState>::value, "struct wrapper is not a standard layout!" );
- 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<VkPipelineDepthStencilStateCreateInfo*>(this) = rhs;
- }
-
- PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(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,
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<vk::PipelineDepthStencilStateCreateInfo const *>(&rhs);
return *this;
}
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<PipelineDepthStencilStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPipelineColorBlendAttachmentState*>(this) = rhs;
+ *this = rhs;
}
PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPipelineColorBlendAttachmentState*>(this) = rhs;
+ *this = *reinterpret_cast<vk::PipelineColorBlendAttachmentState const *>(&rhs);
return *this;
}
static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PipelineColorBlendAttachmentState>::value, "struct wrapper is not a standard layout!" );
- 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<float,4> const& blendConstants_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
- : flags( flags_ )
- , logicOpEnable( logicOpEnable_ )
- , logicOp( logicOp_ )
- , attachmentCount( attachmentCount_ )
- , pAttachments( pAttachments_ )
- , blendConstants{}
- {
- vk::ConstExpressionArrayCopy<float,4,4>::copy( blendConstants, blendConstants_ );
- }
-
- PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this) = rhs;
- }
-
- PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(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,
uint32_t attachmentCount_ = 0,
const vk::PipelineColorBlendAttachmentState* pAttachments_ = nullptr,
std::array<float,4> 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<float,4,4>::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<vk::PipelineColorBlendStateCreateInfo const *>(&rhs);
return *this;
}
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<PipelineColorBlendStateCreateInfo>::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<VkPipelineDynamicStateCreateInfo*>(this) = rhs;
- }
-
- PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(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<vk::PipelineDynamicStateCreateInfo const *>(&rhs);
return *this;
}
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<PipelineDynamicStateCreateInfo>::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<VkGraphicsPipelineCreateInfo*>(this) = rhs;
- }
-
- GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkGraphicsPipelineCreateInfo*>(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,
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<vk::GraphicsPipelineCreateInfo const *>(&rhs);
return *this;
}
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<GraphicsPipelineCreateInfo>::value, "struct wrapper is not a standard layout!" );
XYColorEXT( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkXYColorEXT*>(this) = rhs;
+ *this = rhs;
}
XYColorEXT& operator=( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkXYColorEXT*>(this) = rhs;
+ *this = *reinterpret_cast<vk::XYColorEXT const *>(&rhs);
return *this;
}
static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<XYColorEXT>::value, "struct wrapper is not a standard layout!" );
- 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<VkHdrMetadataEXT*>(this) = rhs;
- }
-
- HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkHdrMetadataEXT*>(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(),
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<vk::HdrMetadataEXT const *>(&rhs);
return *this;
}
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<HdrMetadataEXT>::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<VkHeadlessSurfaceCreateInfoEXT*>(this) = rhs;
- }
-
- HeadlessSurfaceCreateInfoEXT& operator=( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT*>(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<vk::HeadlessSurfaceCreateInfoEXT const *>(&rhs);
return *this;
}
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<HeadlessSurfaceCreateInfoEXT>::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<VkIOSSurfaceCreateInfoMVK*>(this) = rhs;
- }
-
- IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkIOSSurfaceCreateInfoMVK*>(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<vk::IOSSurfaceCreateInfoMVK const *>(&rhs);
return *this;
}
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<IOSSurfaceCreateInfoMVK>::value, "struct wrapper is not a standard layout!" );
ImageBlit( VkImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkImageBlit*>(this) = rhs;
+ *this = rhs;
}
ImageBlit& operator=( VkImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkImageBlit*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ImageBlit const *>(&rhs);
return *this;
}
ImageCopy( VkImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkImageCopy*>(this) = rhs;
+ *this = rhs;
}
ImageCopy& operator=( VkImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkImageCopy*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ImageCopy const *>(&rhs);
return *this;
}
static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<ImageCopy>::value, "struct wrapper is not a standard layout!" );
- 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<VkImageCreateInfo*>(this) = rhs;
- }
-
- ImageCreateInfo& operator=( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageCreateInfo*>(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,
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<vk::ImageCreateInfo const *>(&rhs);
return *this;
}
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<ImageCreateInfo>::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<VkSubresourceLayout*>(this) = rhs;
+ *this = rhs;
}
SubresourceLayout& operator=( VkSubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSubresourceLayout*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SubresourceLayout const *>(&rhs);
return *this;
}
static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<SubresourceLayout>::value, "struct wrapper is not a standard layout!" );
- 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<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this) = rhs;
- }
-
- ImageDrmFormatModifierExplicitCreateInfoEXT& operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(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<vk::ImageDrmFormatModifierExplicitCreateInfoEXT const *>(&rhs);
return *this;
}
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<ImageDrmFormatModifierExplicitCreateInfoEXT>::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<VkImageDrmFormatModifierListCreateInfoEXT*>(this) = rhs;
- }
-
- ImageDrmFormatModifierListCreateInfoEXT& operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(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<vk::ImageDrmFormatModifierListCreateInfoEXT const *>(&rhs);
return *this;
}
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<ImageDrmFormatModifierListCreateInfoEXT>::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<VkImageDrmFormatModifierPropertiesEXT*>(this) = rhs;
- }
-
- ImageDrmFormatModifierPropertiesEXT& operator=( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>(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<vk::ImageDrmFormatModifierPropertiesEXT const *>(&rhs);
return *this;
}
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<ImageDrmFormatModifierPropertiesEXT>::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<VkImageFormatListCreateInfoKHR*>(this) = rhs;
- }
-
- ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageFormatListCreateInfoKHR*>(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<vk::ImageFormatListCreateInfoKHR const *>(&rhs);
return *this;
}
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<ImageFormatListCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct ImageFormatProperties2
- {
- protected:
- ImageFormatProperties2() VULKAN_HPP_NOEXCEPT
- {}
-
- ImageFormatProperties2( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageFormatProperties2*>(this) = rhs;
- }
-
- ImageFormatProperties2& operator=( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageFormatProperties2*>(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
+ struct 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<vk::ImageFormatProperties2 const *>(&rhs);
return *this;
}
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<ImageFormatProperties2>::value, "struct wrapper is not a standard layout!" );
ImageSubresourceRange( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkImageSubresourceRange*>(this) = rhs;
+ *this = rhs;
}
ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkImageSubresourceRange*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ImageSubresourceRange const *>(&rhs);
return *this;
}
static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<ImageSubresourceRange>::value, "struct wrapper is not a standard layout!" );
- 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<VkImageMemoryBarrier*>(this) = rhs;
- }
-
- ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageMemoryBarrier*>(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(),
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<vk::ImageMemoryBarrier const *>(&rhs);
return *this;
}
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<ImageMemoryBarrier>::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<VkImageMemoryRequirementsInfo2*>(this) = rhs;
- }
-
- ImageMemoryRequirementsInfo2& operator=( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageMemoryRequirementsInfo2*>(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<vk::ImageMemoryRequirementsInfo2 const *>(&rhs);
return *this;
}
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<ImageMemoryRequirementsInfo2>::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<VkImagePipeSurfaceCreateInfoFUCHSIA*>(this) = rhs;
- }
-
- ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>(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<vk::ImagePipeSurfaceCreateInfoFUCHSIA const *>(&rhs);
return *this;
}
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<ImagePipeSurfaceCreateInfoFUCHSIA>::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<VkImagePlaneMemoryRequirementsInfo*>(this) = rhs;
- }
-
- ImagePlaneMemoryRequirementsInfo& operator=( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(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<vk::ImagePlaneMemoryRequirementsInfo const *>(&rhs);
return *this;
}
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<ImagePlaneMemoryRequirementsInfo>::value, "struct wrapper is not a standard layout!" );
ImageResolve( VkImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkImageResolve*>(this) = rhs;
+ *this = rhs;
}
ImageResolve& operator=( VkImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkImageResolve*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ImageResolve const *>(&rhs);
return *this;
}
static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<ImageResolve>::value, "struct wrapper is not a standard layout!" );
- 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<VkImageSparseMemoryRequirementsInfo2*>(this) = rhs;
- }
-
- ImageSparseMemoryRequirementsInfo2& operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>(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<vk::ImageSparseMemoryRequirementsInfo2 const *>(&rhs);
return *this;
}
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<ImageSparseMemoryRequirementsInfo2>::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<VkImageStencilUsageCreateInfoEXT*>(this) = rhs;
- }
-
- ImageStencilUsageCreateInfoEXT& operator=( VkImageStencilUsageCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageStencilUsageCreateInfoEXT*>(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<vk::ImageStencilUsageCreateInfoEXT const *>(&rhs);
return *this;
}
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<ImageStencilUsageCreateInfoEXT>::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<VkImageSwapchainCreateInfoKHR*>(this) = rhs;
- }
-
- ImageSwapchainCreateInfoKHR& operator=( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(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<vk::ImageSwapchainCreateInfoKHR const *>(&rhs);
return *this;
}
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<ImageSwapchainCreateInfoKHR>::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<VkImageViewASTCDecodeModeEXT*>(this) = rhs;
- }
-
- ImageViewASTCDecodeModeEXT& operator=( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(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<vk::ImageViewASTCDecodeModeEXT const *>(&rhs);
return *this;
}
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<ImageViewASTCDecodeModeEXT>::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<VkImageViewCreateInfo*>(this) = rhs;
- }
-
- ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageViewCreateInfo*>(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(),
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<vk::ImageViewCreateInfo const *>(&rhs);
return *this;
}
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<ImageViewCreateInfo>::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<VkImageViewHandleInfoNVX*>(this) = rhs;
- }
-
- ImageViewHandleInfoNVX& operator=( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageViewHandleInfoNVX*>(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<vk::ImageViewHandleInfoNVX const *>(&rhs);
return *this;
}
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<ImageViewHandleInfoNVX>::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<VkImageViewUsageCreateInfo*>(this) = rhs;
- }
-
- ImageViewUsageCreateInfo& operator=( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImageViewUsageCreateInfo*>(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<vk::ImageViewUsageCreateInfo const *>(&rhs);
return *this;
}
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<ImageViewUsageCreateInfo>::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<VkImportAndroidHardwareBufferInfoANDROID*>(this) = rhs;
- }
-
- ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(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<vk::ImportAndroidHardwareBufferInfoANDROID const *>(&rhs);
return *this;
}
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<ImportAndroidHardwareBufferInfoANDROID>::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<VkImportFenceFdInfoKHR*>(this) = rhs;
- }
-
- ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImportFenceFdInfoKHR*>(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<vk::ImportFenceFdInfoKHR const *>(&rhs);
return *this;
}
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<ImportFenceFdInfoKHR>::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<VkImportFenceWin32HandleInfoKHR*>(this) = rhs;
- }
-
- ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>(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<vk::ImportFenceWin32HandleInfoKHR const *>(&rhs);
return *this;
}
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<ImportFenceWin32HandleInfoKHR>::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<VkImportMemoryFdInfoKHR*>(this) = rhs;
- }
-
- ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImportMemoryFdInfoKHR*>(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<vk::ImportMemoryFdInfoKHR const *>(&rhs);
return *this;
}
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<ImportMemoryFdInfoKHR>::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<VkImportMemoryHostPointerInfoEXT*>(this) = rhs;
- }
-
- ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(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<vk::ImportMemoryHostPointerInfoEXT const *>(&rhs);
return *this;
}
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<ImportMemoryHostPointerInfoEXT>::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<VkImportMemoryWin32HandleInfoKHR*>(this) = rhs;
- }
-
- ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(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<vk::ImportMemoryWin32HandleInfoKHR const *>(&rhs);
return *this;
}
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<ImportMemoryWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
#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<VkImportMemoryWin32HandleInfoNV*>(this) = rhs;
- }
-
- ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(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<vk::ImportMemoryWin32HandleInfoNV const *>(&rhs);
return *this;
}
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<ImportMemoryWin32HandleInfoNV>::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<VkImportSemaphoreFdInfoKHR*>(this) = rhs;
- }
-
- ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImportSemaphoreFdInfoKHR*>(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<vk::ImportSemaphoreFdInfoKHR const *>(&rhs);
return *this;
}
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<ImportSemaphoreFdInfoKHR>::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<VkImportSemaphoreWin32HandleInfoKHR*>(this) = rhs;
- }
-
- ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>(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<vk::ImportSemaphoreWin32HandleInfoKHR const *>(&rhs);
return *this;
}
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<ImportSemaphoreWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkIndirectCommandsLayoutTokenNVX*>(this) = rhs;
+ *this = rhs;
}
IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkIndirectCommandsLayoutTokenNVX*>(this) = rhs;
+ *this = *reinterpret_cast<vk::IndirectCommandsLayoutTokenNVX const *>(&rhs);
return *this;
}
static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<IndirectCommandsLayoutTokenNVX>::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<VkIndirectCommandsLayoutCreateInfoNVX*>(this) = rhs;
- }
-
- IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX*>(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<vk::IndirectCommandsLayoutCreateInfoNVX const *>(&rhs);
return *this;
}
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<IndirectCommandsLayoutCreateInfoNVX>::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<VkInitializePerformanceApiInfoINTEL*>(this) = rhs;
- }
-
- InitializePerformanceApiInfoINTEL& operator=( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkInitializePerformanceApiInfoINTEL*>(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<vk::InitializePerformanceApiInfoINTEL const *>(&rhs);
return *this;
}
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<InitializePerformanceApiInfoINTEL>::value, "struct wrapper is not a standard layout!" );
InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkInputAttachmentAspectReference*>(this) = rhs;
+ *this = rhs;
}
InputAttachmentAspectReference& operator=( VkInputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkInputAttachmentAspectReference*>(this) = rhs;
+ *this = *reinterpret_cast<vk::InputAttachmentAspectReference const *>(&rhs);
return *this;
}
static_assert( sizeof( InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<InputAttachmentAspectReference>::value, "struct wrapper is not a standard layout!" );
- 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<VkInstanceCreateInfo*>(this) = rhs;
- }
-
- InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkInstanceCreateInfo*>(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,
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<vk::InstanceCreateInfo const *>(&rhs);
return *this;
}
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<InstanceCreateInfo>::value, "struct wrapper is not a standard layout!" );
struct LayerProperties
{
- LayerProperties() VULKAN_HPP_NOEXCEPT
- {}
+ LayerProperties( std::array<char,VK_MAX_EXTENSION_NAME_SIZE> const& layerName_ = { { 0 } },
+ uint32_t specVersion_ = 0,
+ uint32_t implementationVersion_ = 0,
+ std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
+ : layerName{}
+ , specVersion( specVersion_ )
+ , implementationVersion( implementationVersion_ )
+ , description{}
+ {
+ vk::ConstExpressionArrayCopy<char,VK_MAX_EXTENSION_NAME_SIZE,VK_MAX_EXTENSION_NAME_SIZE>::copy( layerName, layerName_ );
+ vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
+ }
LayerProperties( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkLayerProperties*>(this) = rhs;
+ *this = rhs;
}
LayerProperties& operator=( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkLayerProperties*>(this) = rhs;
+ *this = *reinterpret_cast<vk::LayerProperties const *>(&rhs);
return *this;
}
#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<VkMacOSSurfaceCreateInfoMVK*>(this) = rhs;
- }
-
- MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK*>(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<vk::MacOSSurfaceCreateInfoMVK const *>(&rhs);
return *this;
}
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<MacOSSurfaceCreateInfoMVK>::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<VkMappedMemoryRange*>(this) = rhs;
- }
-
- MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMappedMemoryRange*>(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<vk::MappedMemoryRange const *>(&rhs);
return *this;
}
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<MappedMemoryRange>::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<VkMemoryAllocateFlagsInfo*>(this) = rhs;
- }
-
- MemoryAllocateFlagsInfo& operator=( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryAllocateFlagsInfo*>(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<vk::MemoryAllocateFlagsInfo const *>(&rhs);
return *this;
}
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<MemoryAllocateFlagsInfo>::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<VkMemoryAllocateInfo*>(this) = rhs;
- }
-
- MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryAllocateInfo*>(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<vk::MemoryAllocateInfo const *>(&rhs);
return *this;
}
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<MemoryAllocateInfo>::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<VkMemoryBarrier*>(this) = rhs;
- }
-
- MemoryBarrier& operator=( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryBarrier*>(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<vk::MemoryBarrier const *>(&rhs);
return *this;
}
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<MemoryBarrier>::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<VkMemoryDedicatedAllocateInfo*>(this) = rhs;
- }
-
- MemoryDedicatedAllocateInfo& operator=( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(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<vk::MemoryDedicatedAllocateInfo const *>(&rhs);
return *this;
}
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<MemoryDedicatedAllocateInfo>::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<VkMemoryDedicatedRequirements*>(this) = rhs;
- }
-
- MemoryDedicatedRequirements& operator=( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryDedicatedRequirements*>(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<vk::MemoryDedicatedRequirements const *>(&rhs);
return *this;
}
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<MemoryDedicatedRequirements>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct MemoryFdPropertiesKHR
- {
- protected:
- MemoryFdPropertiesKHR() VULKAN_HPP_NOEXCEPT
- {}
-
- MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryFdPropertiesKHR*>(this) = rhs;
- }
-
- MemoryFdPropertiesKHR& operator=( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryFdPropertiesKHR*>(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
+ struct 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<vk::MemoryFdPropertiesKHR const *>(&rhs);
return *this;
}
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<MemoryFdPropertiesKHR>::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<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this) = rhs;
- }
-
- MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(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<vk::MemoryGetAndroidHardwareBufferInfoANDROID const *>(&rhs);
return *this;
}
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<MemoryGetAndroidHardwareBufferInfoANDROID>::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<VkMemoryGetFdInfoKHR*>(this) = rhs;
- }
-
- MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryGetFdInfoKHR*>(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<vk::MemoryGetFdInfoKHR const *>(&rhs);
return *this;
}
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<MemoryGetFdInfoKHR>::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<VkMemoryGetWin32HandleInfoKHR*>(this) = rhs;
- }
-
- MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>(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<vk::MemoryGetWin32HandleInfoKHR const *>(&rhs);
return *this;
}
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<MemoryGetWin32HandleInfoKHR>::value, "struct wrapper is not a standard layout!" );
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<VkMemoryHeap*>(this) = rhs;
+ *this = rhs;
}
MemoryHeap& operator=( VkMemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkMemoryHeap*>(this) = rhs;
+ *this = *reinterpret_cast<vk::MemoryHeap const *>(&rhs);
return *this;
}
static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<MemoryHeap>::value, "struct wrapper is not a standard layout!" );
- namespace layout
+ struct MemoryHostPointerPropertiesEXT
{
- struct MemoryHostPointerPropertiesEXT
- {
- protected:
- MemoryHostPointerPropertiesEXT() VULKAN_HPP_NOEXCEPT
- {}
-
- MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>(this) = rhs;
- }
-
- MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>(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<vk::MemoryHostPointerPropertiesEXT const *>(&rhs);
return *this;
}
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<MemoryHostPointerPropertiesEXT>::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<VkMemoryPriorityAllocateInfoEXT*>(this) = rhs;
- }
-
- MemoryPriorityAllocateInfoEXT& operator=( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(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<vk::MemoryPriorityAllocateInfoEXT const *>(&rhs);
return *this;
}
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<MemoryPriorityAllocateInfoEXT>::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<VkMemoryRequirements*>(this) = rhs;
+ *this = rhs;
}
MemoryRequirements& operator=( VkMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkMemoryRequirements*>(this) = rhs;
+ *this = *reinterpret_cast<vk::MemoryRequirements const *>(&rhs);
return *this;
}
static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<MemoryRequirements>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct MemoryRequirements2
- {
- protected:
- MemoryRequirements2() VULKAN_HPP_NOEXCEPT
- {}
-
- MemoryRequirements2( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryRequirements2*>(this) = rhs;
- }
-
- MemoryRequirements2& operator=( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryRequirements2*>(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
+ struct 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<vk::MemoryRequirements2 const *>(&rhs);
return *this;
}
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<MemoryRequirements2>::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<VkMemoryType*>(this) = rhs;
+ *this = rhs;
}
MemoryType& operator=( VkMemoryType const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkMemoryType*>(this) = rhs;
+ *this = *reinterpret_cast<vk::MemoryType const *>(&rhs);
return *this;
}
#ifdef VK_USE_PLATFORM_WIN32_KHR
- namespace layout
- {
- struct MemoryWin32HandlePropertiesKHR
- {
- protected:
- MemoryWin32HandlePropertiesKHR() VULKAN_HPP_NOEXCEPT
- {}
-
- MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>(this) = rhs;
- }
-
- MemoryWin32HandlePropertiesKHR& operator=( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>(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
+ struct 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<vk::MemoryWin32HandlePropertiesKHR const *>(&rhs);
return *this;
}
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<MemoryWin32HandlePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
#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<VkMetalSurfaceCreateInfoEXT*>(this) = rhs;
- }
-
- MetalSurfaceCreateInfoEXT& operator=( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMetalSurfaceCreateInfoEXT*>(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<vk::MetalSurfaceCreateInfoEXT const *>(&rhs);
return *this;
}
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<MetalSurfaceCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
#endif /*VK_USE_PLATFORM_METAL_EXT*/
- namespace layout
- {
- struct MultisamplePropertiesEXT
- {
- protected:
- MultisamplePropertiesEXT() VULKAN_HPP_NOEXCEPT
- {}
-
- MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMultisamplePropertiesEXT*>(this) = rhs;
- }
-
- MultisamplePropertiesEXT& operator=( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkMultisamplePropertiesEXT*>(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
+ struct 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<vk::MultisamplePropertiesEXT const *>(&rhs);
return *this;
}
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<MultisamplePropertiesEXT>::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<VkObjectTableCreateInfoNVX*>(this) = rhs;
- }
-
- ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkObjectTableCreateInfoNVX*>(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,
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<vk::ObjectTableCreateInfoNVX const *>(&rhs);
return *this;
}
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<ObjectTableCreateInfoNVX>::value, "struct wrapper is not a standard layout!" );
ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkObjectTableEntryNVX*>(this) = rhs;
+ *this = rhs;
}
ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkObjectTableEntryNVX*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ObjectTableEntryNVX const *>(&rhs);
return *this;
}
ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkObjectTableDescriptorSetEntryNVX*>(this) = rhs;
+ *this = rhs;
}
ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkObjectTableDescriptorSetEntryNVX*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ObjectTableDescriptorSetEntryNVX const *>(&rhs);
return *this;
}
ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkObjectTableIndexBufferEntryNVX*>(this) = rhs;
+ *this = rhs;
}
ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkObjectTableIndexBufferEntryNVX*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ObjectTableIndexBufferEntryNVX const *>(&rhs);
return *this;
}
ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkObjectTablePipelineEntryNVX*>(this) = rhs;
+ *this = rhs;
}
ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkObjectTablePipelineEntryNVX*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ObjectTablePipelineEntryNVX const *>(&rhs);
return *this;
}
ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkObjectTablePushConstantEntryNVX*>(this) = rhs;
+ *this = rhs;
}
ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkObjectTablePushConstantEntryNVX*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ObjectTablePushConstantEntryNVX const *>(&rhs);
return *this;
}
ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkObjectTableVertexBufferEntryNVX*>(this) = rhs;
+ *this = rhs;
}
ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkObjectTableVertexBufferEntryNVX*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ObjectTableVertexBufferEntryNVX const *>(&rhs);
return *this;
}
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<VkPastPresentationTimingGOOGLE*>(this) = rhs;
+ *this = rhs;
}
PastPresentationTimingGOOGLE& operator=( VkPastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPastPresentationTimingGOOGLE*>(this) = rhs;
+ *this = *reinterpret_cast<vk::PastPresentationTimingGOOGLE const *>(&rhs);
return *this;
}
static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PastPresentationTimingGOOGLE>::value, "struct wrapper is not a standard layout!" );
- 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<VkPerformanceConfigurationAcquireInfoINTEL*>(this) = rhs;
- }
-
- PerformanceConfigurationAcquireInfoINTEL& operator=( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL*>(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<vk::PerformanceConfigurationAcquireInfoINTEL const *>(&rhs);
return *this;
}
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<PerformanceConfigurationAcquireInfoINTEL>::value, "struct wrapper is not a standard layout!" );
- namespace layout
+ struct PerformanceCounterDescriptionKHR
{
- struct PerformanceMarkerInfoINTEL
+ PerformanceCounterDescriptionKHR( vk::PerformanceCounterDescriptionFlagsKHR flags_ = vk::PerformanceCounterDescriptionFlagsKHR(),
+ std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = { { 0 } },
+ std::array<char,VK_MAX_DESCRIPTION_SIZE> const& category_ = { { 0 } },
+ std::array<char,VK_MAX_DESCRIPTION_SIZE> 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<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
+ vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( category, category_ );
+ vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
+ }
- PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPerformanceMarkerInfoINTEL*>(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<VkPerformanceMarkerInfoINTEL*>(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<vk::PerformanceCounterDescriptionKHR const *>(&rhs);
+ return *this;
+ }
+
+ operator VkPerformanceCounterDescriptionKHR const&() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkPerformanceCounterDescriptionKHR*>( this );
+ }
+
+ operator VkPerformanceCounterDescriptionKHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkPerformanceCounterDescriptionKHR*>( 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<PerformanceCounterDescriptionKHR>::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<uint8_t,VK_UUID_SIZE> const& uuid_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
+ : unit( unit_ )
+ , scope( scope_ )
+ , storage( storage_ )
+ , uuid{}
+ {
+ vk::ConstExpressionArrayCopy<uint8_t,VK_UUID_SIZE,VK_UUID_SIZE>::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<vk::PerformanceCounterKHR const *>(&rhs);
+ return *this;
+ }
+
+ operator VkPerformanceCounterKHR const&() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkPerformanceCounterKHR*>( this );
+ }
+
+ operator VkPerformanceCounterKHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkPerformanceCounterKHR*>( 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<PerformanceCounterKHR>::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<const VkPerformanceCounterResultKHR*>(this);
+ }
- struct PerformanceMarkerInfoINTEL : public layout::PerformanceMarkerInfoINTEL
+ operator VkPerformanceCounterResultKHR &()
+ {
+ return *reinterpret_cast<VkPerformanceCounterResultKHR*>(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<vk::PerformanceMarkerInfoINTEL const *>(&rhs);
return *this;
}
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<PerformanceMarkerInfoINTEL>::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<VkPerformanceOverrideInfoINTEL*>(this) = rhs;
- }
-
- PerformanceOverrideInfoINTEL& operator=( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPerformanceOverrideInfoINTEL*>(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<vk::PerformanceOverrideInfoINTEL const *>(&rhs);
return *this;
}
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<PerformanceOverrideInfoINTEL>::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<VkPerformanceStreamMarkerInfoINTEL*>(this) = rhs;
- }
+ PerformanceQuerySubmitInfoKHR( VkPerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = rhs;
+ }
- PerformanceStreamMarkerInfoINTEL& operator=( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL*>(this) = rhs;
- return *this;
- }
+ PerformanceQuerySubmitInfoKHR& operator=( VkPerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<vk::PerformanceQuerySubmitInfoKHR const *>(&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;
+ }
+
+ PerformanceQuerySubmitInfoKHR & setCounterPassIndex( uint32_t counterPassIndex_ ) VULKAN_HPP_NOEXCEPT
+ {
+ counterPassIndex = counterPassIndex_;
+ return *this;
+ }
- struct PerformanceStreamMarkerInfoINTEL : public layout::PerformanceStreamMarkerInfoINTEL
+ operator VkPerformanceQuerySubmitInfoKHR const&() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>( this );
+ }
+
+ operator VkPerformanceQuerySubmitInfoKHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>( 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<PerformanceQuerySubmitInfoKHR>::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<vk::PerformanceStreamMarkerInfoINTEL const *>(&rhs);
return *this;
}
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<PerformanceStreamMarkerInfoINTEL>::value, "struct wrapper is not a standard layout!" );
PerformanceValueINTEL( VkPerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPerformanceValueINTEL*>(this) = rhs;
+ *this = rhs;
}
PerformanceValueINTEL& operator=( VkPerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPerformanceValueINTEL*>(this) = rhs;
+ *this = *reinterpret_cast<vk::PerformanceValueINTEL const *>(&rhs);
return *this;
}
static_assert( sizeof( PerformanceValueINTEL ) == sizeof( VkPerformanceValueINTEL ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PerformanceValueINTEL>::value, "struct wrapper is not a standard layout!" );
- 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<VkPhysicalDevice16BitStorageFeatures*>(this) = rhs;
- }
-
- PhysicalDevice16BitStorageFeatures& operator=( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(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<vk::PhysicalDevice16BitStorageFeatures const *>(&rhs);
return *this;
}
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<PhysicalDevice16BitStorageFeatures>::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<VkPhysicalDevice8BitStorageFeaturesKHR*>(this) = rhs;
- }
-
- PhysicalDevice8BitStorageFeaturesKHR& operator=( VkPhysicalDevice8BitStorageFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(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<vk::PhysicalDevice8BitStorageFeaturesKHR const *>(&rhs);
return *this;
}
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<PhysicalDevice8BitStorageFeaturesKHR>::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<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceASTCDecodeFeaturesEXT& operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(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<vk::PhysicalDeviceASTCDecodeFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceASTCDecodeFeaturesEXT>::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<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(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<vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceBlendOperationAdvancedFeaturesEXT>::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<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(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<vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceBlendOperationAdvancedPropertiesEXT>::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<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(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<vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceBufferDeviceAddressFeaturesEXT>::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<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(this) = rhs;
- }
-
- PhysicalDeviceCoherentMemoryFeaturesAMD& operator=( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(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<vk::PhysicalDeviceCoherentMemoryFeaturesAMD const *>(&rhs);
return *this;
}
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<PhysicalDeviceCoherentMemoryFeaturesAMD>::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<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this) = rhs;
- }
-
- PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(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<vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceComputeShaderDerivativesFeaturesNV>::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<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceConditionalRenderingFeaturesEXT& operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(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<vk::PhysicalDeviceConditionalRenderingFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceConditionalRenderingFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceConservativeRasterizationPropertiesEXT
- {
- protected:
- PhysicalDeviceConservativeRasterizationPropertiesEXT() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(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
+ struct 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<vk::PhysicalDeviceConservativeRasterizationPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceConservativeRasterizationPropertiesEXT>::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<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(this) = rhs;
- }
-
- PhysicalDeviceCooperativeMatrixFeaturesNV& operator=( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(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<vk::PhysicalDeviceCooperativeMatrixFeaturesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceCooperativeMatrixFeaturesNV>::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<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(this) = rhs;
- }
-
- PhysicalDeviceCooperativeMatrixPropertiesNV& operator=( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(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<vk::PhysicalDeviceCooperativeMatrixPropertiesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceCooperativeMatrixPropertiesNV>::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<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this) = rhs;
- }
-
- PhysicalDeviceCornerSampledImageFeaturesNV& operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(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<vk::PhysicalDeviceCornerSampledImageFeaturesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceCornerSampledImageFeaturesNV>::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<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(this) = rhs;
- }
-
- PhysicalDeviceCoverageReductionModeFeaturesNV& operator=( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(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<vk::PhysicalDeviceCoverageReductionModeFeaturesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceCoverageReductionModeFeaturesNV>::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<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(this) = rhs;
- }
-
- PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(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<vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>::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<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceDepthClipEnableFeaturesEXT& operator=( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(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<vk::PhysicalDeviceDepthClipEnableFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceDepthClipEnableFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceDepthStencilResolvePropertiesKHR
- {
- protected:
- PhysicalDeviceDepthStencilResolvePropertiesKHR() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceDepthStencilResolvePropertiesKHR( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceDepthStencilResolvePropertiesKHR*>(this) = rhs;
- }
-
- PhysicalDeviceDepthStencilResolvePropertiesKHR& operator=( VkPhysicalDeviceDepthStencilResolvePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceDepthStencilResolvePropertiesKHR*>(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
+ struct 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<vk::PhysicalDeviceDepthStencilResolvePropertiesKHR const *>(&rhs);
return *this;
}
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<PhysicalDeviceDepthStencilResolvePropertiesKHR>::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<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceDescriptorIndexingFeaturesEXT& operator=( VkPhysicalDeviceDescriptorIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(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,
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<vk::PhysicalDeviceDescriptorIndexingFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceDescriptorIndexingFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceDescriptorIndexingPropertiesEXT
- {
- protected:
- PhysicalDeviceDescriptorIndexingPropertiesEXT() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceDescriptorIndexingPropertiesEXT( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceDescriptorIndexingPropertiesEXT& operator=( VkPhysicalDeviceDescriptorIndexingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(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()
- {}
+ struct 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<vk::PhysicalDeviceDescriptorIndexingPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceDescriptorIndexingPropertiesEXT>::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<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(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<vk::PhysicalDeviceDiscardRectanglePropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceDiscardRectanglePropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
+ struct PhysicalDeviceDriverPropertiesKHR
{
- struct PhysicalDeviceDriverPropertiesKHR
+ PhysicalDeviceDriverPropertiesKHR( vk::DriverIdKHR driverID_ = vk::DriverIdKHR::eAmdProprietary,
+ std::array<char,VK_MAX_DRIVER_NAME_SIZE_KHR> const& driverName_ = { { 0 } },
+ std::array<char,VK_MAX_DRIVER_INFO_SIZE_KHR> const& driverInfo_ = { { 0 } },
+ vk::ConformanceVersionKHR conformanceVersion_ = vk::ConformanceVersionKHR() ) VULKAN_HPP_NOEXCEPT
+ : driverID( driverID_ )
+ , driverName{}
+ , driverInfo{}
+ , conformanceVersion( conformanceVersion_ )
{
- protected:
- PhysicalDeviceDriverPropertiesKHR() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceDriverPropertiesKHR( VkPhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR*>(this) = rhs;
- }
-
- PhysicalDeviceDriverPropertiesKHR& operator=( VkPhysicalDeviceDriverPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR*>(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!" );
- }
+ vk::ConstExpressionArrayCopy<char,VK_MAX_DRIVER_NAME_SIZE_KHR,VK_MAX_DRIVER_NAME_SIZE_KHR>::copy( driverName, driverName_ );
+ vk::ConstExpressionArrayCopy<char,VK_MAX_DRIVER_INFO_SIZE_KHR,VK_MAX_DRIVER_INFO_SIZE_KHR>::copy( driverInfo, driverInfo_ );
+ }
- 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<vk::PhysicalDeviceDriverPropertiesKHR const *>(&rhs);
return *this;
}
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<PhysicalDeviceDriverPropertiesKHR>::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<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this) = rhs;
- }
-
- PhysicalDeviceExclusiveScissorFeaturesNV& operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(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<vk::PhysicalDeviceExclusiveScissorFeaturesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceExclusiveScissorFeaturesNV>::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<VkPhysicalDeviceExternalBufferInfo*>(this) = rhs;
- }
-
- PhysicalDeviceExternalBufferInfo& operator=( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>(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<vk::PhysicalDeviceExternalBufferInfo const *>(&rhs);
return *this;
}
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<PhysicalDeviceExternalBufferInfo>::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<VkPhysicalDeviceExternalFenceInfo*>(this) = rhs;
- }
-
- PhysicalDeviceExternalFenceInfo& operator=( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>(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<vk::PhysicalDeviceExternalFenceInfo const *>(&rhs);
return *this;
}
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<PhysicalDeviceExternalFenceInfo>::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<VkPhysicalDeviceExternalImageFormatInfo*>(this) = rhs;
- }
-
- PhysicalDeviceExternalImageFormatInfo& operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(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<vk::PhysicalDeviceExternalImageFormatInfo const *>(&rhs);
return *this;
}
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<PhysicalDeviceExternalImageFormatInfo>::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<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(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<vk::PhysicalDeviceExternalMemoryHostPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceExternalMemoryHostPropertiesEXT>::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<VkPhysicalDeviceExternalSemaphoreInfo*>(this) = rhs;
- }
-
- PhysicalDeviceExternalSemaphoreInfo& operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>(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<vk::PhysicalDeviceExternalSemaphoreInfo const *>(&rhs);
return *this;
}
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<PhysicalDeviceExternalSemaphoreInfo>::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<VkPhysicalDeviceFeatures2*>(this) = rhs;
- }
-
- PhysicalDeviceFeatures2& operator=( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceFeatures2*>(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<vk::PhysicalDeviceFeatures2 const *>(&rhs);
return *this;
}
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<PhysicalDeviceFeatures2>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceFloatControlsPropertiesKHR
- {
- protected:
- PhysicalDeviceFloatControlsPropertiesKHR() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceFloatControlsPropertiesKHR( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceFloatControlsPropertiesKHR*>(this) = rhs;
- }
-
- PhysicalDeviceFloatControlsPropertiesKHR& operator=( VkPhysicalDeviceFloatControlsPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceFloatControlsPropertiesKHR*>(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()
- {}
+ struct 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<vk::PhysicalDeviceFloatControlsPropertiesKHR const *>(&rhs);
return *this;
}
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<PhysicalDeviceFloatControlsPropertiesKHR>::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<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceFragmentDensityMapFeaturesEXT& operator=( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(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<vk::PhysicalDeviceFragmentDensityMapFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceFragmentDensityMapFeaturesEXT>::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<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceFragmentDensityMapPropertiesEXT& operator=( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(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<vk::PhysicalDeviceFragmentDensityMapPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceFragmentDensityMapPropertiesEXT>::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<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this) = rhs;
- }
-
- PhysicalDeviceFragmentShaderBarycentricFeaturesNV& operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(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<vk::PhysicalDeviceFragmentShaderBarycentricFeaturesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceFragmentShaderBarycentricFeaturesNV>::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<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(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<vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceFragmentShaderInterlockFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
+ struct PhysicalDeviceGroupProperties
{
- struct PhysicalDeviceGroupProperties
+ PhysicalDeviceGroupProperties( uint32_t physicalDeviceCount_ = 0,
+ std::array<vk::PhysicalDevice,VK_MAX_DEVICE_GROUP_SIZE> const& physicalDevices_ = { { vk::PhysicalDevice() } },
+ vk::Bool32 subsetAllocation_ = 0 ) VULKAN_HPP_NOEXCEPT
+ : physicalDeviceCount( physicalDeviceCount_ )
+ , physicalDevices{}
+ , subsetAllocation( subsetAllocation_ )
{
- protected:
- PhysicalDeviceGroupProperties() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceGroupProperties( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceGroupProperties*>(this) = rhs;
- }
-
- PhysicalDeviceGroupProperties& operator=( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceGroupProperties*>(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!" );
- }
+ vk::ConstExpressionArrayCopy<vk::PhysicalDevice,VK_MAX_DEVICE_GROUP_SIZE,VK_MAX_DEVICE_GROUP_SIZE>::copy( physicalDevices, physicalDevices_ );
+ }
- 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<vk::PhysicalDeviceGroupProperties const *>(&rhs);
return *this;
}
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<PhysicalDeviceGroupProperties>::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<VkPhysicalDeviceHostQueryResetFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceHostQueryResetFeaturesEXT& operator=( VkPhysicalDeviceHostQueryResetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceHostQueryResetFeaturesEXT*>(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<vk::PhysicalDeviceHostQueryResetFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceHostQueryResetFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
+ struct PhysicalDeviceIDProperties
{
- struct PhysicalDeviceIDProperties
+ PhysicalDeviceIDProperties( std::array<uint8_t,VK_UUID_SIZE> const& deviceUUID_ = { { 0 } },
+ std::array<uint8_t,VK_UUID_SIZE> const& driverUUID_ = { { 0 } },
+ std::array<uint8_t,VK_LUID_SIZE> 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
- {}
-
- PhysicalDeviceIDProperties( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceIDProperties*>(this) = rhs;
- }
-
- PhysicalDeviceIDProperties& operator=( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceIDProperties*>(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!" );
- }
+ vk::ConstExpressionArrayCopy<uint8_t,VK_UUID_SIZE,VK_UUID_SIZE>::copy( deviceUUID, deviceUUID_ );
+ vk::ConstExpressionArrayCopy<uint8_t,VK_UUID_SIZE,VK_UUID_SIZE>::copy( driverUUID, driverUUID_ );
+ vk::ConstExpressionArrayCopy<uint8_t,VK_LUID_SIZE,VK_LUID_SIZE>::copy( deviceLUID, deviceLUID_ );
+ }
- 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<vk::PhysicalDeviceIDProperties const *>(&rhs);
return *this;
}
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<PhysicalDeviceIDProperties>::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<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this) = rhs;
- }
-
- PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(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<vk::PhysicalDeviceImageDrmFormatModifierInfoEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceImageDrmFormatModifierInfoEXT>::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<VkPhysicalDeviceImageFormatInfo2*>(this) = rhs;
- }
-
- PhysicalDeviceImageFormatInfo2& operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>(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<vk::PhysicalDeviceImageFormatInfo2 const *>(&rhs);
return *this;
}
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<PhysicalDeviceImageFormatInfo2>::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<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(this) = rhs;
- }
-
- PhysicalDeviceImageViewImageFormatInfoEXT& operator=( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(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<vk::PhysicalDeviceImageViewImageFormatInfoEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceImageViewImageFormatInfoEXT>::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<VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>(this) = rhs;
- }
-
- PhysicalDeviceImagelessFramebufferFeaturesKHR& operator=( VkPhysicalDeviceImagelessFramebufferFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeaturesKHR*>(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<vk::PhysicalDeviceImagelessFramebufferFeaturesKHR const *>(&rhs);
return *this;
}
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<PhysicalDeviceImagelessFramebufferFeaturesKHR>::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<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceIndexTypeUint8FeaturesEXT& operator=( VkPhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(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<vk::PhysicalDeviceIndexTypeUint8FeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceIndexTypeUint8FeaturesEXT>::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<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceInlineUniformBlockFeaturesEXT& operator=( VkPhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(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<vk::PhysicalDeviceInlineUniformBlockFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceInlineUniformBlockFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceInlineUniformBlockPropertiesEXT
- {
- protected:
- PhysicalDeviceInlineUniformBlockPropertiesEXT() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceInlineUniformBlockPropertiesEXT( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceInlineUniformBlockPropertiesEXT& operator=( VkPhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(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
+ struct 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<vk::PhysicalDeviceInlineUniformBlockPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceInlineUniformBlockPropertiesEXT>::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<uint32_t,3> const& maxComputeWorkGroupCount_ = { { 0 } },
+ uint32_t maxComputeWorkGroupInvocations_ = 0,
+ std::array<uint32_t,3> 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<uint32_t,2> const& maxViewportDimensions_ = { { 0 } },
+ std::array<float,2> 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<float,2> const& pointSizeRange_ = { { 0 } },
+ std::array<float,2> 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<uint32_t,3,3>::copy( maxComputeWorkGroupCount, maxComputeWorkGroupCount_ );
+ vk::ConstExpressionArrayCopy<uint32_t,3,3>::copy( maxComputeWorkGroupSize, maxComputeWorkGroupSize_ );
+ vk::ConstExpressionArrayCopy<uint32_t,2,2>::copy( maxViewportDimensions, maxViewportDimensions_ );
+ vk::ConstExpressionArrayCopy<float,2,2>::copy( viewportBoundsRange, viewportBoundsRange_ );
+ vk::ConstExpressionArrayCopy<float,2,2>::copy( pointSizeRange, pointSizeRange_ );
+ vk::ConstExpressionArrayCopy<float,2,2>::copy( lineWidthRange, lineWidthRange_ );
+ }
PhysicalDeviceLimits( VkPhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPhysicalDeviceLimits*>(this) = rhs;
+ *this = rhs;
}
PhysicalDeviceLimits& operator=( VkPhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPhysicalDeviceLimits*>(this) = rhs;
+ *this = *reinterpret_cast<vk::PhysicalDeviceLimits const *>(&rhs);
return *this;
}
static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PhysicalDeviceLimits>::value, "struct wrapper is not a standard layout!" );
- 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<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceLineRasterizationFeaturesEXT& operator=( VkPhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(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,
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<vk::PhysicalDeviceLineRasterizationFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceLineRasterizationFeaturesEXT>::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<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceLineRasterizationPropertiesEXT& operator=( VkPhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(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<vk::PhysicalDeviceLineRasterizationPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceLineRasterizationPropertiesEXT>::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<VkPhysicalDeviceMaintenance3Properties*>(this) = rhs;
- }
-
- PhysicalDeviceMaintenance3Properties& operator=( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(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<vk::PhysicalDeviceMaintenance3Properties const *>(&rhs);
return *this;
}
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<PhysicalDeviceMaintenance3Properties>::value, "struct wrapper is not a standard layout!" );
- namespace layout
+ struct PhysicalDeviceMemoryBudgetPropertiesEXT
{
- struct PhysicalDeviceMemoryBudgetPropertiesEXT
+ PhysicalDeviceMemoryBudgetPropertiesEXT( std::array<vk::DeviceSize,VK_MAX_MEMORY_HEAPS> const& heapBudget_ = { { 0 } },
+ std::array<vk::DeviceSize,VK_MAX_MEMORY_HEAPS> const& heapUsage_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
+ : heapBudget{}
+ , heapUsage{}
{
- protected:
- PhysicalDeviceMemoryBudgetPropertiesEXT() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceMemoryBudgetPropertiesEXT( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceMemoryBudgetPropertiesEXT& operator=( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(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!" );
- }
+ vk::ConstExpressionArrayCopy<vk::DeviceSize,VK_MAX_MEMORY_HEAPS,VK_MAX_MEMORY_HEAPS>::copy( heapBudget, heapBudget_ );
+ vk::ConstExpressionArrayCopy<vk::DeviceSize,VK_MAX_MEMORY_HEAPS,VK_MAX_MEMORY_HEAPS>::copy( heapUsage, heapUsage_ );
+ }
- 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<vk::PhysicalDeviceMemoryBudgetPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceMemoryBudgetPropertiesEXT>::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<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceMemoryPriorityFeaturesEXT& operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(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<vk::PhysicalDeviceMemoryPriorityFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceMemoryPriorityFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
struct PhysicalDeviceMemoryProperties
{
- PhysicalDeviceMemoryProperties() VULKAN_HPP_NOEXCEPT
- {}
+ PhysicalDeviceMemoryProperties( uint32_t memoryTypeCount_ = 0,
+ std::array<vk::MemoryType,VK_MAX_MEMORY_TYPES> const& memoryTypes_ = { { vk::MemoryType() } },
+ uint32_t memoryHeapCount_ = 0,
+ std::array<vk::MemoryHeap,VK_MAX_MEMORY_HEAPS> const& memoryHeaps_ = { { vk::MemoryHeap() } } ) VULKAN_HPP_NOEXCEPT
+ : memoryTypeCount( memoryTypeCount_ )
+ , memoryTypes{}
+ , memoryHeapCount( memoryHeapCount_ )
+ , memoryHeaps{}
+ {
+ vk::ConstExpressionArrayCopy<vk::MemoryType,VK_MAX_MEMORY_TYPES,VK_MAX_MEMORY_TYPES>::copy( memoryTypes, memoryTypes_ );
+ vk::ConstExpressionArrayCopy<vk::MemoryHeap,VK_MAX_MEMORY_HEAPS,VK_MAX_MEMORY_HEAPS>::copy( memoryHeaps, memoryHeaps_ );
+ }
PhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPhysicalDeviceMemoryProperties*>(this) = rhs;
+ *this = rhs;
}
PhysicalDeviceMemoryProperties& operator=( VkPhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPhysicalDeviceMemoryProperties*>(this) = rhs;
+ *this = *reinterpret_cast<vk::PhysicalDeviceMemoryProperties const *>(&rhs);
return *this;
}
static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PhysicalDeviceMemoryProperties>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceMemoryProperties2
- {
- protected:
- PhysicalDeviceMemoryProperties2() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceMemoryProperties2( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>(this) = rhs;
- }
-
- PhysicalDeviceMemoryProperties2& operator=( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>(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
+ struct 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<vk::PhysicalDeviceMemoryProperties2 const *>(&rhs);
return *this;
}
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<PhysicalDeviceMemoryProperties2>::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<VkPhysicalDeviceMeshShaderFeaturesNV*>(this) = rhs;
- }
-
- PhysicalDeviceMeshShaderFeaturesNV& operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(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<vk::PhysicalDeviceMeshShaderFeaturesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceMeshShaderFeaturesNV>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceMeshShaderPropertiesNV
- {
- protected:
- PhysicalDeviceMeshShaderPropertiesNV() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(this) = rhs;
- }
-
- PhysicalDeviceMeshShaderPropertiesNV& operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(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()
- {}
+ struct PhysicalDeviceMeshShaderPropertiesNV
+ {
+ PhysicalDeviceMeshShaderPropertiesNV( uint32_t maxDrawMeshTasksCount_ = 0,
+ uint32_t maxTaskWorkGroupInvocations_ = 0,
+ std::array<uint32_t,3> const& maxTaskWorkGroupSize_ = { { 0 } },
+ uint32_t maxTaskTotalMemorySize_ = 0,
+ uint32_t maxTaskOutputCount_ = 0,
+ uint32_t maxMeshWorkGroupInvocations_ = 0,
+ std::array<uint32_t,3> 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_ )
+ {
+ vk::ConstExpressionArrayCopy<uint32_t,3,3>::copy( maxTaskWorkGroupSize, maxTaskWorkGroupSize_ );
+ vk::ConstExpressionArrayCopy<uint32_t,3,3>::copy( maxMeshWorkGroupSize, maxMeshWorkGroupSize_ );
+ }
+
+ 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<vk::PhysicalDeviceMeshShaderPropertiesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceMeshShaderPropertiesNV>::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<VkPhysicalDeviceMultiviewFeatures*>(this) = rhs;
- }
-
- PhysicalDeviceMultiviewFeatures& operator=( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(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<vk::PhysicalDeviceMultiviewFeatures const *>(&rhs);
return *this;
}
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<PhysicalDeviceMultiviewFeatures>::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<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this) = rhs;
- }
-
- PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(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<vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const *>(&rhs);
return *this;
}
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<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>::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<VkPhysicalDeviceMultiviewProperties*>(this) = rhs;
- }
-
- PhysicalDeviceMultiviewProperties& operator=( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(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<vk::PhysicalDeviceMultiviewProperties const *>(&rhs);
return *this;
}
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<PhysicalDeviceMultiviewProperties>::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<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDevicePCIBusInfoPropertiesEXT& operator=( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(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<vk::PhysicalDevicePCIBusInfoPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDevicePCIBusInfoPropertiesEXT>::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<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(this) = rhs;
- }
+ PhysicalDevicePerformanceQueryFeaturesKHR( VkPhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = rhs;
+ }
- PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(this) = rhs;
- return *this;
- }
+ PhysicalDevicePerformanceQueryFeaturesKHR& operator=( VkPhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<vk::PhysicalDevicePerformanceQueryFeaturesKHR const *>(&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;
+ }
+
+ 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<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>( this );
+ }
+
+ operator VkPhysicalDevicePerformanceQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>( this );
+ }
- struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR : public layout::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
+ 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<PhysicalDevicePerformanceQueryFeaturesKHR>::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<vk::PhysicalDevicePerformanceQueryPropertiesKHR const *>(&rhs);
+ return *this;
+ }
+
+ operator VkPhysicalDevicePerformanceQueryPropertiesKHR const&() const VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>( this );
+ }
+
+ operator VkPhysicalDevicePerformanceQueryPropertiesKHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>( 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<PhysicalDevicePerformanceQueryPropertiesKHR>::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<vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const *>(&rhs);
return *this;
}
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<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>::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<VkPhysicalDevicePointClippingProperties*>(this) = rhs;
- }
-
- PhysicalDevicePointClippingProperties& operator=( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(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<vk::PhysicalDevicePointClippingProperties const *>(&rhs);
return *this;
}
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<PhysicalDevicePointClippingProperties>::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<VkPhysicalDeviceSparseProperties*>(this) = rhs;
+ *this = rhs;
}
PhysicalDeviceSparseProperties& operator=( VkPhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPhysicalDeviceSparseProperties*>(this) = rhs;
+ *this = *reinterpret_cast<vk::PhysicalDeviceSparseProperties const *>(&rhs);
return *this;
}
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<char,VK_MAX_PHYSICAL_DEVICE_NAME_SIZE> const& deviceName_ = { { 0 } },
+ std::array<uint8_t,VK_UUID_SIZE> 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<char,VK_MAX_PHYSICAL_DEVICE_NAME_SIZE,VK_MAX_PHYSICAL_DEVICE_NAME_SIZE>::copy( deviceName, deviceName_ );
+ vk::ConstExpressionArrayCopy<uint8_t,VK_UUID_SIZE,VK_UUID_SIZE>::copy( pipelineCacheUUID, pipelineCacheUUID_ );
+ }
PhysicalDeviceProperties( VkPhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPhysicalDeviceProperties*>(this) = rhs;
+ *this = rhs;
}
PhysicalDeviceProperties& operator=( VkPhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPhysicalDeviceProperties*>(this) = rhs;
+ *this = *reinterpret_cast<vk::PhysicalDeviceProperties const *>(&rhs);
return *this;
}
static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PhysicalDeviceProperties>::value, "struct wrapper is not a standard layout!" );
- namespace layout
+ struct PhysicalDeviceProperties2
{
- struct PhysicalDeviceProperties2
- {
- protected:
- PhysicalDeviceProperties2() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceProperties2( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceProperties2*>(this) = rhs;
- }
-
- PhysicalDeviceProperties2& operator=( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceProperties2*>(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<vk::PhysicalDeviceProperties2 const *>(&rhs);
return *this;
}
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<PhysicalDeviceProperties2>::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<VkPhysicalDeviceProtectedMemoryFeatures*>(this) = rhs;
- }
-
- PhysicalDeviceProtectedMemoryFeatures& operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(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<vk::PhysicalDeviceProtectedMemoryFeatures const *>(&rhs);
return *this;
}
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<PhysicalDeviceProtectedMemoryFeatures>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceProtectedMemoryProperties
- {
- protected:
- PhysicalDeviceProtectedMemoryProperties() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(this) = rhs;
- }
-
- PhysicalDeviceProtectedMemoryProperties& operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(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
+ struct 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<vk::PhysicalDeviceProtectedMemoryProperties const *>(&rhs);
return *this;
}
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<PhysicalDeviceProtectedMemoryProperties>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDevicePushDescriptorPropertiesKHR
- {
- protected:
- PhysicalDevicePushDescriptorPropertiesKHR() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(this) = rhs;
- }
-
- PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(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
+ struct 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<vk::PhysicalDevicePushDescriptorPropertiesKHR const *>(&rhs);
return *this;
}
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<PhysicalDevicePushDescriptorPropertiesKHR>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceRayTracingPropertiesNV
- {
- protected:
- PhysicalDeviceRayTracingPropertiesNV() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(this) = rhs;
- }
-
- PhysicalDeviceRayTracingPropertiesNV& operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(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
+ struct 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<vk::PhysicalDeviceRayTracingPropertiesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceRayTracingPropertiesNV>::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<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this) = rhs;
- }
-
- PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(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<vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceRepresentativeFragmentTestFeaturesNV>::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<float,2> 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
- {}
-
- PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceSampleLocationsPropertiesEXT& operator=( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(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!" );
- }
+ vk::ConstExpressionArrayCopy<float,2,2>::copy( sampleLocationCoordinateRange, sampleLocationCoordinateRange_ );
+ }
- 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<vk::PhysicalDeviceSampleLocationsPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceSampleLocationsPropertiesEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT
- {
- protected:
- PhysicalDeviceSamplerFilterMinmaxPropertiesEXT() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceSamplerFilterMinmaxPropertiesEXT( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceSamplerFilterMinmaxPropertiesEXT& operator=( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(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
+ struct 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<vk::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceSamplerFilterMinmaxPropertiesEXT>::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<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this) = rhs;
- }
-
- PhysicalDeviceSamplerYcbcrConversionFeatures& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(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<vk::PhysicalDeviceSamplerYcbcrConversionFeatures const *>(&rhs);
return *this;
}
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<PhysicalDeviceSamplerYcbcrConversionFeatures>::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<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceScalarBlockLayoutFeaturesEXT& operator=( VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT*>(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<vk::PhysicalDeviceScalarBlockLayoutFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceScalarBlockLayoutFeaturesEXT>::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<VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR*>(this) = rhs;
- }
-
- PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR& operator=( VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR*>(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<vk::PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR const *>(&rhs);
return *this;
}
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<PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR>::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<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>(this) = rhs;
- }
-
- PhysicalDeviceShaderAtomicInt64FeaturesKHR& operator=( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>(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<vk::PhysicalDeviceShaderAtomicInt64FeaturesKHR const *>(&rhs);
return *this;
}
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<PhysicalDeviceShaderAtomicInt64FeaturesKHR>::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<VkPhysicalDeviceShaderClockFeaturesKHR*>(this) = rhs;
- }
-
- PhysicalDeviceShaderClockFeaturesKHR& operator=( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(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<vk::PhysicalDeviceShaderClockFeaturesKHR const *>(&rhs);
return *this;
}
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<PhysicalDeviceShaderClockFeaturesKHR>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceShaderCoreProperties2AMD
- {
- protected:
- PhysicalDeviceShaderCoreProperties2AMD() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceShaderCoreProperties2AMD( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(this) = rhs;
- }
-
- PhysicalDeviceShaderCoreProperties2AMD& operator=( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(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
+ struct 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<vk::PhysicalDeviceShaderCoreProperties2AMD const *>(&rhs);
return *this;
}
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<PhysicalDeviceShaderCoreProperties2AMD>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceShaderCorePropertiesAMD
- {
- protected:
- PhysicalDeviceShaderCorePropertiesAMD() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceShaderCorePropertiesAMD( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(this) = rhs;
- }
-
- PhysicalDeviceShaderCorePropertiesAMD& operator=( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(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()
- {}
+ struct 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<vk::PhysicalDeviceShaderCorePropertiesAMD const *>(&rhs);
return *this;
}
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<PhysicalDeviceShaderCorePropertiesAMD>::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<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& operator=( VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(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<vk::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>::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<VkPhysicalDeviceShaderDrawParametersFeatures*>(this) = rhs;
- }
-
- PhysicalDeviceShaderDrawParametersFeatures& operator=( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(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<vk::PhysicalDeviceShaderDrawParametersFeatures const *>(&rhs);
return *this;
}
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<PhysicalDeviceShaderDrawParametersFeatures>::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<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR*>(this) = rhs;
- }
-
- PhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=( VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR*>(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<vk::PhysicalDeviceShaderFloat16Int8FeaturesKHR const *>(&rhs);
return *this;
}
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<PhysicalDeviceShaderFloat16Int8FeaturesKHR>::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<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this) = rhs;
- }
-
- PhysicalDeviceShaderImageFootprintFeaturesNV& operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(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<vk::PhysicalDeviceShaderImageFootprintFeaturesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceShaderImageFootprintFeaturesNV>::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<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(this) = rhs;
- }
-
- PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(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<vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const *>(&rhs);
return *this;
}
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<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>::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<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(this) = rhs;
- }
-
- PhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(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<vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceShaderSMBuiltinsFeaturesNV>::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<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(this) = rhs;
- }
-
- PhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(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<vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceShaderSMBuiltinsPropertiesNV>::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<VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR*>(this) = rhs;
- }
-
- PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR& operator=( VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR*>(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<vk::PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR const *>(&rhs);
return *this;
}
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<PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR>::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<VkPhysicalDeviceShadingRateImageFeaturesNV*>(this) = rhs;
- }
-
- PhysicalDeviceShadingRateImageFeaturesNV& operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(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<vk::PhysicalDeviceShadingRateImageFeaturesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceShadingRateImageFeaturesNV>::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<VkPhysicalDeviceShadingRateImagePropertiesNV*>(this) = rhs;
- }
-
- PhysicalDeviceShadingRateImagePropertiesNV& operator=( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(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<vk::PhysicalDeviceShadingRateImagePropertiesNV const *>(&rhs);
return *this;
}
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<PhysicalDeviceShadingRateImagePropertiesNV>::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<VkPhysicalDeviceSparseImageFormatInfo2*>(this) = rhs;
- }
-
- PhysicalDeviceSparseImageFormatInfo2& operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>(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<vk::PhysicalDeviceSparseImageFormatInfo2 const *>(&rhs);
return *this;
}
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<PhysicalDeviceSparseImageFormatInfo2>::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<VkPhysicalDeviceSubgroupProperties*>(this) = rhs;
- }
-
- PhysicalDeviceSubgroupProperties& operator=( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(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<vk::PhysicalDeviceSubgroupProperties const *>(&rhs);
return *this;
}
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<PhysicalDeviceSubgroupProperties>::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<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(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<vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceSubgroupSizeControlFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceSubgroupSizeControlPropertiesEXT
- {
- protected:
- PhysicalDeviceSubgroupSizeControlPropertiesEXT() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceSubgroupSizeControlPropertiesEXT( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceSubgroupSizeControlPropertiesEXT& operator=( VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(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
+ struct 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<vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceSubgroupSizeControlPropertiesEXT>::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<VkPhysicalDeviceSurfaceInfo2KHR*>(this) = rhs;
- }
-
- PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(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<vk::PhysicalDeviceSurfaceInfo2KHR const *>(&rhs);
return *this;
}
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<PhysicalDeviceSurfaceInfo2KHR>::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<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(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<vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceTexelBufferAlignmentFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT
- {
- protected:
- PhysicalDeviceTexelBufferAlignmentPropertiesEXT() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceTexelBufferAlignmentPropertiesEXT( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceTexelBufferAlignmentPropertiesEXT& operator=( VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(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
+ struct 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<vk::PhysicalDeviceTexelBufferAlignmentPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceTexelBufferAlignmentPropertiesEXT>::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<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(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_ )
{}
+ vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & operator=( vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ memcpy( &pNext, &rhs.pNext, sizeof( vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) - sizeof( vk::StructureType ) );
+ return *this;
+ }
+
PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- : layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT( rhs )
- {}
+ {
+ *this = rhs;
+ }
PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- layout::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::operator=(rhs);
+ *this = *reinterpret_cast<vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const *>(&rhs);
return *this;
}
- PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & setPNext( const void* pNext_ ) VULKAN_HPP_NOEXCEPT
+ PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & setPNext( void* pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
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<PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>::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<VkPhysicalDeviceTimelineSemaphoreFeaturesKHR*>(this) = rhs;
- }
-
- PhysicalDeviceTimelineSemaphoreFeaturesKHR& operator=( VkPhysicalDeviceTimelineSemaphoreFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeaturesKHR*>(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<vk::PhysicalDeviceTimelineSemaphoreFeaturesKHR const *>(&rhs);
return *this;
}
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<PhysicalDeviceTimelineSemaphoreFeaturesKHR>::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<VkPhysicalDeviceTimelineSemaphorePropertiesKHR*>(this) = rhs;
- }
-
- PhysicalDeviceTimelineSemaphorePropertiesKHR& operator=( VkPhysicalDeviceTimelineSemaphorePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceTimelineSemaphorePropertiesKHR*>(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<vk::PhysicalDeviceTimelineSemaphorePropertiesKHR const *>(&rhs);
return *this;
}
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<PhysicalDeviceTimelineSemaphorePropertiesKHR>::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<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceTransformFeedbackFeaturesEXT& operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(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<vk::PhysicalDeviceTransformFeedbackFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceTransformFeedbackFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceTransformFeedbackPropertiesEXT
- {
- protected:
- PhysicalDeviceTransformFeedbackPropertiesEXT() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceTransformFeedbackPropertiesEXT( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceTransformFeedbackPropertiesEXT& operator=( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(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
+ struct 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<vk::PhysicalDeviceTransformFeedbackPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceTransformFeedbackPropertiesEXT>::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<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR*>(this) = rhs;
- }
-
- PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& operator=( VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR*>(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<vk::PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const *>(&rhs);
return *this;
}
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<PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR>::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<VkPhysicalDeviceVariablePointersFeatures*>(this) = rhs;
- }
-
- PhysicalDeviceVariablePointersFeatures& operator=( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(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<vk::PhysicalDeviceVariablePointersFeatures const *>(&rhs);
return *this;
}
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<PhysicalDeviceVariablePointersFeatures>::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<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceVertexAttributeDivisorFeaturesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(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<vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceVertexAttributeDivisorFeaturesEXT>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT
- {
- protected:
- PhysicalDeviceVertexAttributeDivisorPropertiesEXT() VULKAN_HPP_NOEXCEPT
- {}
-
- PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(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
+ struct 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<vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceVertexAttributeDivisorPropertiesEXT>::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<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this) = rhs;
- }
-
- PhysicalDeviceVulkanMemoryModelFeaturesKHR& operator=( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(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<vk::PhysicalDeviceVulkanMemoryModelFeaturesKHR const *>(&rhs);
return *this;
}
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<PhysicalDeviceVulkanMemoryModelFeaturesKHR>::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<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(this) = rhs;
- }
-
- PhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(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<vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT const *>(&rhs);
return *this;
}
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<PhysicalDeviceYcbcrImageArraysFeaturesEXT>::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<VkPipelineCacheCreateInfo*>(this) = rhs;
- }
-
- PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineCacheCreateInfo*>(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<vk::PipelineCacheCreateInfo const *>(&rhs);
return *this;
}
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<PipelineCacheCreateInfo>::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<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this) = rhs;
- }
-
- PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(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<vk::PipelineColorBlendAdvancedStateCreateInfoEXT const *>(&rhs);
return *this;
}
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<PipelineColorBlendAdvancedStateCreateInfoEXT>::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<VkPipelineCompilerControlCreateInfoAMD*>(this) = rhs;
- }
-
- PipelineCompilerControlCreateInfoAMD& operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(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<vk::PipelineCompilerControlCreateInfoAMD const *>(&rhs);
return *this;
}
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<PipelineCompilerControlCreateInfoAMD>::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<VkPipelineCoverageModulationStateCreateInfoNV*>(this) = rhs;
- }
-
- PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(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<vk::PipelineCoverageModulationStateCreateInfoNV const *>(&rhs);
return *this;
}
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<PipelineCoverageModulationStateCreateInfoNV>::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<VkPipelineCoverageReductionStateCreateInfoNV*>(this) = rhs;
- }
-
- PipelineCoverageReductionStateCreateInfoNV& operator=( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(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<vk::PipelineCoverageReductionStateCreateInfoNV const *>(&rhs);
return *this;
}
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<PipelineCoverageReductionStateCreateInfoNV>::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<VkPipelineCoverageToColorStateCreateInfoNV*>(this) = rhs;
- }
-
- PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(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<vk::PipelineCoverageToColorStateCreateInfoNV const *>(&rhs);
return *this;
}
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<PipelineCoverageToColorStateCreateInfoNV>::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<VkPipelineCreationFeedbackEXT*>(this) = rhs;
+ *this = rhs;
}
PipelineCreationFeedbackEXT& operator=( VkPipelineCreationFeedbackEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPipelineCreationFeedbackEXT*>(this) = rhs;
+ *this = *reinterpret_cast<vk::PipelineCreationFeedbackEXT const *>(&rhs);
return *this;
}
static_assert( sizeof( PipelineCreationFeedbackEXT ) == sizeof( VkPipelineCreationFeedbackEXT ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PipelineCreationFeedbackEXT>::value, "struct wrapper is not a standard layout!" );
- 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<VkPipelineCreationFeedbackCreateInfoEXT*>(this) = rhs;
- }
-
- PipelineCreationFeedbackCreateInfoEXT& operator=( VkPipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(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<vk::PipelineCreationFeedbackCreateInfoEXT const *>(&rhs);
return *this;
}
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<PipelineCreationFeedbackCreateInfoEXT>::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<VkPipelineDiscardRectangleStateCreateInfoEXT*>(this) = rhs;
- }
-
- PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(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<vk::PipelineDiscardRectangleStateCreateInfoEXT const *>(&rhs);
return *this;
}
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<PipelineDiscardRectangleStateCreateInfoEXT>::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<VkPipelineExecutableInfoKHR*>(this) = rhs;
- }
-
- PipelineExecutableInfoKHR& operator=( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineExecutableInfoKHR*>(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<vk::PipelineExecutableInfoKHR const *>(&rhs);
return *this;
}
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<PipelineExecutableInfoKHR>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct PipelineExecutableInternalRepresentationKHR
- {
- protected:
- VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInternalRepresentationKHR( std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = { { 0 } },
- std::array<char,VK_MAX_DESCRIPTION_SIZE> 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<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
- vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
- }
-
- PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>(this) = rhs;
- }
-
- PipelineExecutableInternalRepresentationKHR& operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>(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<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = { { 0 } },
std::array<char,VK_MAX_DESCRIPTION_SIZE> 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<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
+ vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::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<vk::PipelineExecutableInternalRepresentationKHR const *>(&rhs);
return *this;
}
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<PipelineExecutableInternalRepresentationKHR>::value, "struct wrapper is not a standard layout!" );
- namespace layout
+ struct PipelineExecutablePropertiesKHR
{
- struct PipelineExecutablePropertiesKHR
+ PipelineExecutablePropertiesKHR( vk::ShaderStageFlags stages_ = vk::ShaderStageFlags(),
+ std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = { { 0 } },
+ std::array<char,VK_MAX_DESCRIPTION_SIZE> const& description_ = { { 0 } },
+ uint32_t subgroupSize_ = 0 ) VULKAN_HPP_NOEXCEPT
+ : stages( stages_ )
+ , name{}
+ , description{}
+ , subgroupSize( subgroupSize_ )
{
- protected:
- PipelineExecutablePropertiesKHR() VULKAN_HPP_NOEXCEPT
- {}
-
- PipelineExecutablePropertiesKHR( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineExecutablePropertiesKHR*>(this) = rhs;
- }
-
- PipelineExecutablePropertiesKHR& operator=( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineExecutablePropertiesKHR*>(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!" );
- }
+ vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
+ vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
+ }
- 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<vk::PipelineExecutablePropertiesKHR const *>(&rhs);
return *this;
}
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<PipelineExecutablePropertiesKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
};
- namespace layout
+ struct PipelineExecutableStatisticKHR
{
- struct PipelineExecutableStatisticKHR
+ PipelineExecutableStatisticKHR( std::array<char,VK_MAX_DESCRIPTION_SIZE> const& name_ = { { 0 } },
+ std::array<char,VK_MAX_DESCRIPTION_SIZE> 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
- {}
-
- PipelineExecutableStatisticKHR( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineExecutableStatisticKHR*>(this) = rhs;
- }
-
- PipelineExecutableStatisticKHR& operator=( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineExecutableStatisticKHR*>(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!" );
- }
+ vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( name, name_ );
+ vk::ConstExpressionArrayCopy<char,VK_MAX_DESCRIPTION_SIZE,VK_MAX_DESCRIPTION_SIZE>::copy( description, description_ );
+ }
- 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<vk::PipelineExecutableStatisticKHR const *>(&rhs);
return *this;
}
return *reinterpret_cast<VkPipelineExecutableStatisticKHR*>( 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<PipelineExecutableStatisticKHR>::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<VkPipelineInfoKHR*>(this) = rhs;
- }
-
- PipelineInfoKHR& operator=( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineInfoKHR*>(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<vk::PipelineInfoKHR const *>(&rhs);
return *this;
}
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<PipelineInfoKHR>::value, "struct wrapper is not a standard layout!" );
PushConstantRange( VkPushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPushConstantRange*>(this) = rhs;
+ *this = rhs;
}
PushConstantRange& operator=( VkPushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPushConstantRange*>(this) = rhs;
+ *this = *reinterpret_cast<vk::PushConstantRange const *>(&rhs);
return *this;
}
static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PushConstantRange>::value, "struct wrapper is not a standard layout!" );
- 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<VkPipelineLayoutCreateInfo*>(this) = rhs;
- }
-
- PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineLayoutCreateInfo*>(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<vk::PipelineLayoutCreateInfo const *>(&rhs);
return *this;
}
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<PipelineLayoutCreateInfo>::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<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this) = rhs;
- }
-
- PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(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<vk::PipelineRasterizationConservativeStateCreateInfoEXT const *>(&rhs);
return *this;
}
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<PipelineRasterizationConservativeStateCreateInfoEXT>::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<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(this) = rhs;
- }
-
- PipelineRasterizationDepthClipStateCreateInfoEXT& operator=( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(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<vk::PipelineRasterizationDepthClipStateCreateInfoEXT const *>(&rhs);
return *this;
}
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<PipelineRasterizationDepthClipStateCreateInfoEXT>::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<VkPipelineRasterizationLineStateCreateInfoEXT*>(this) = rhs;
- }
-
- PipelineRasterizationLineStateCreateInfoEXT& operator=( VkPipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(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<vk::PipelineRasterizationLineStateCreateInfoEXT const *>(&rhs);
return *this;
}
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<PipelineRasterizationLineStateCreateInfoEXT>::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<VkPipelineRasterizationStateRasterizationOrderAMD*>(this) = rhs;
- }
-
- PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(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<vk::PipelineRasterizationStateRasterizationOrderAMD const *>(&rhs);
return *this;
}
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<PipelineRasterizationStateRasterizationOrderAMD>::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<VkPipelineRasterizationStateStreamCreateInfoEXT*>(this) = rhs;
- }
-
- PipelineRasterizationStateStreamCreateInfoEXT& operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(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<vk::PipelineRasterizationStateStreamCreateInfoEXT const *>(&rhs);
return *this;
}
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<PipelineRasterizationStateStreamCreateInfoEXT>::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<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this) = rhs;
- }
-
- PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(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<vk::PipelineRepresentativeFragmentTestStateCreateInfoNV const *>(&rhs);
return *this;
}
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<PipelineRepresentativeFragmentTestStateCreateInfoNV>::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<VkPipelineSampleLocationsStateCreateInfoEXT*>(this) = rhs;
- }
-
- PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(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<vk::PipelineSampleLocationsStateCreateInfoEXT const *>(&rhs);
return *this;
}
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<PipelineSampleLocationsStateCreateInfoEXT>::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<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(this) = rhs;
- }
-
- PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& operator=( VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(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<vk::PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const *>(&rhs);
return *this;
}
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<PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT>::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<VkPipelineTessellationDomainOriginStateCreateInfo*>(this) = rhs;
- }
-
- PipelineTessellationDomainOriginStateCreateInfo& operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(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<vk::PipelineTessellationDomainOriginStateCreateInfo const *>(&rhs);
return *this;
}
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<PipelineTessellationDomainOriginStateCreateInfo>::value, "struct wrapper is not a standard layout!" );
VertexInputBindingDivisorDescriptionEXT( VkVertexInputBindingDivisorDescriptionEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT*>(this) = rhs;
+ *this = rhs;
}
VertexInputBindingDivisorDescriptionEXT& operator=( VkVertexInputBindingDivisorDescriptionEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT*>(this) = rhs;
+ *this = *reinterpret_cast<vk::VertexInputBindingDivisorDescriptionEXT const *>(&rhs);
return *this;
}
static_assert( sizeof( VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<VertexInputBindingDivisorDescriptionEXT>::value, "struct wrapper is not a standard layout!" );
- 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<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this) = rhs;
- }
-
- PipelineVertexInputDivisorStateCreateInfoEXT& operator=( VkPipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(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<vk::PipelineVertexInputDivisorStateCreateInfoEXT const *>(&rhs);
return *this;
}
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<PipelineVertexInputDivisorStateCreateInfoEXT>::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<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this) = rhs;
- }
-
- PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(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<vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV const *>(&rhs);
return *this;
}
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<PipelineViewportCoarseSampleOrderStateCreateInfoNV>::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<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this) = rhs;
- }
-
- PipelineViewportExclusiveScissorStateCreateInfoNV& operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(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<vk::PipelineViewportExclusiveScissorStateCreateInfoNV const *>(&rhs);
return *this;
}
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<PipelineViewportExclusiveScissorStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkShadingRatePaletteNV*>(this) = rhs;
+ *this = rhs;
}
ShadingRatePaletteNV& operator=( VkShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkShadingRatePaletteNV*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ShadingRatePaletteNV const *>(&rhs);
return *this;
}
static_assert( sizeof( ShadingRatePaletteNV ) == sizeof( VkShadingRatePaletteNV ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<ShadingRatePaletteNV>::value, "struct wrapper is not a standard layout!" );
- 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<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this) = rhs;
- }
-
- PipelineViewportShadingRateImageStateCreateInfoNV& operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(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<vk::PipelineViewportShadingRateImageStateCreateInfoNV const *>(&rhs);
return *this;
}
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<PipelineViewportShadingRateImageStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
ViewportSwizzleNV( VkViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkViewportSwizzleNV*>(this) = rhs;
+ *this = rhs;
}
ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkViewportSwizzleNV*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ViewportSwizzleNV const *>(&rhs);
return *this;
}
static_assert( sizeof( ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<ViewportSwizzleNV>::value, "struct wrapper is not a standard layout!" );
- 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<VkPipelineViewportSwizzleStateCreateInfoNV*>(this) = rhs;
- }
-
- PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(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<vk::PipelineViewportSwizzleStateCreateInfoNV const *>(&rhs);
return *this;
}
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<PipelineViewportSwizzleStateCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
ViewportWScalingNV( VkViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkViewportWScalingNV*>(this) = rhs;
+ *this = rhs;
}
ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkViewportWScalingNV*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ViewportWScalingNV const *>(&rhs);
return *this;
}
static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<ViewportWScalingNV>::value, "struct wrapper is not a standard layout!" );
- 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<VkPipelineViewportWScalingStateCreateInfoNV*>(this) = rhs;
- }
-
- PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(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<vk::PipelineViewportWScalingStateCreateInfoNV const *>(&rhs);
return *this;
}
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<PipelineViewportWScalingStateCreateInfoNV>::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<VkPresentFrameTokenGGP*>(this) = rhs;
- }
-
- PresentFrameTokenGGP& operator=( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPresentFrameTokenGGP*>(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<vk::PresentFrameTokenGGP const *>(&rhs);
return *this;
}
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<PresentFrameTokenGGP>::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<VkPresentInfoKHR*>(this) = rhs;
- }
-
- PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPresentInfoKHR*>(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,
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<vk::PresentInfoKHR const *>(&rhs);
return *this;
}
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<PresentInfoKHR>::value, "struct wrapper is not a standard layout!" );
RectLayerKHR( VkRectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkRectLayerKHR*>(this) = rhs;
+ *this = rhs;
}
RectLayerKHR& operator=( VkRectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkRectLayerKHR*>(this) = rhs;
+ *this = *reinterpret_cast<vk::RectLayerKHR const *>(&rhs);
return *this;
}
PresentRegionKHR( VkPresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPresentRegionKHR*>(this) = rhs;
+ *this = rhs;
}
PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPresentRegionKHR*>(this) = rhs;
+ *this = *reinterpret_cast<vk::PresentRegionKHR const *>(&rhs);
return *this;
}
static_assert( sizeof( PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PresentRegionKHR>::value, "struct wrapper is not a standard layout!" );
- 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<VkPresentRegionsKHR*>(this) = rhs;
- }
-
- PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPresentRegionsKHR*>(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<vk::PresentRegionsKHR const *>(&rhs);
return *this;
}
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<PresentRegionsKHR>::value, "struct wrapper is not a standard layout!" );
PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPresentTimeGOOGLE*>(this) = rhs;
+ *this = rhs;
}
PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkPresentTimeGOOGLE*>(this) = rhs;
+ *this = *reinterpret_cast<vk::PresentTimeGOOGLE const *>(&rhs);
return *this;
}
static_assert( sizeof( PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<PresentTimeGOOGLE>::value, "struct wrapper is not a standard layout!" );
- 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<VkPresentTimesInfoGOOGLE*>(this) = rhs;
- }
-
- PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkPresentTimesInfoGOOGLE*>(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<vk::PresentTimesInfoGOOGLE const *>(&rhs);
return *this;
}
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<PresentTimesInfoGOOGLE>::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<VkProtectedSubmitInfo*>(this) = rhs;
- }
-
- ProtectedSubmitInfo& operator=( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkProtectedSubmitInfo*>(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<vk::ProtectedSubmitInfo const *>(&rhs);
return *this;
}
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<ProtectedSubmitInfo>::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<VkQueryPoolCreateInfo*>(this) = rhs;
- }
-
- QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkQueryPoolCreateInfo*>(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<vk::QueryPoolCreateInfo const *>(&rhs);
return *this;
}
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<QueryPoolCreateInfo>::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<VkQueryPoolCreateInfoINTEL*>(this) = rhs;
- }
-
- QueryPoolCreateInfoINTEL& operator=( VkQueryPoolCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkQueryPoolCreateInfoINTEL*>(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<vk::QueryPoolCreateInfoINTEL const *>(&rhs);
return *this;
}
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<QueryPoolCreateInfoINTEL>::value, "struct wrapper is not a standard layout!" );
- namespace layout
+ struct QueryPoolPerformanceCreateInfoKHR
{
- struct 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
{
- protected:
- QueueFamilyCheckpointPropertiesNV() VULKAN_HPP_NOEXCEPT
- {}
+ memcpy( &pNext, &rhs.pNext, sizeof( vk::QueryPoolPerformanceCreateInfoKHR ) - sizeof( vk::StructureType ) );
+ return *this;
+ }
- QueueFamilyCheckpointPropertiesNV( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(this) = rhs;
- }
+ QueryPoolPerformanceCreateInfoKHR( VkQueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = rhs;
+ }
- QueueFamilyCheckpointPropertiesNV& operator=( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(this) = rhs;
- return *this;
- }
+ QueryPoolPerformanceCreateInfoKHR& operator=( VkQueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ *this = *reinterpret_cast<vk::QueryPoolPerformanceCreateInfoKHR const *>(&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!" );
- }
+ 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<const VkQueryPoolPerformanceCreateInfoKHR*>( this );
+ }
- struct QueueFamilyCheckpointPropertiesNV : public layout::QueueFamilyCheckpointPropertiesNV
+ operator VkQueryPoolPerformanceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT
+ {
+ return *reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>( 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<QueryPoolPerformanceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
+
+ struct QueueFamilyCheckpointPropertiesNV
{
- QueueFamilyCheckpointPropertiesNV() VULKAN_HPP_NOEXCEPT
- : layout::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<vk::QueueFamilyCheckpointPropertiesNV const *>(&rhs);
return *this;
}
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<QueueFamilyCheckpointPropertiesNV>::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<VkQueueFamilyProperties*>(this) = rhs;
+ *this = rhs;
}
QueueFamilyProperties& operator=( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkQueueFamilyProperties*>(this) = rhs;
+ *this = *reinterpret_cast<vk::QueueFamilyProperties const *>(&rhs);
return *this;
}
static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<QueueFamilyProperties>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct QueueFamilyProperties2
- {
- protected:
- QueueFamilyProperties2() VULKAN_HPP_NOEXCEPT
- {}
-
- QueueFamilyProperties2( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkQueueFamilyProperties2*>(this) = rhs;
- }
-
- QueueFamilyProperties2& operator=( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkQueueFamilyProperties2*>(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
+ struct 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<vk::QueueFamilyProperties2 const *>(&rhs);
return *this;
}
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<QueueFamilyProperties2>::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<VkRayTracingShaderGroupCreateInfoNV*>(this) = rhs;
- }
-
- RayTracingShaderGroupCreateInfoNV& operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>(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<vk::RayTracingShaderGroupCreateInfoNV const *>(&rhs);
return *this;
}
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<RayTracingShaderGroupCreateInfoNV>::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<VkRayTracingPipelineCreateInfoNV*>(this) = rhs;
- }
-
- RayTracingPipelineCreateInfoNV& operator=( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>(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,
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<vk::RayTracingPipelineCreateInfoNV const *>(&rhs);
return *this;
}
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<RayTracingPipelineCreateInfoNV>::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<VkRefreshCycleDurationGOOGLE*>(this) = rhs;
+ *this = rhs;
}
RefreshCycleDurationGOOGLE& operator=( VkRefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkRefreshCycleDurationGOOGLE*>(this) = rhs;
+ *this = *reinterpret_cast<vk::RefreshCycleDurationGOOGLE const *>(&rhs);
return *this;
}
static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<RefreshCycleDurationGOOGLE>::value, "struct wrapper is not a standard layout!" );
- 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<VkRenderPassAttachmentBeginInfoKHR*>(this) = rhs;
- }
-
- RenderPassAttachmentBeginInfoKHR& operator=( VkRenderPassAttachmentBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkRenderPassAttachmentBeginInfoKHR*>(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<vk::RenderPassAttachmentBeginInfoKHR const *>(&rhs);
return *this;
}
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<RenderPassAttachmentBeginInfoKHR>::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<VkRenderPassBeginInfo*>(this) = rhs;
- }
-
- RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkRenderPassBeginInfo*>(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<vk::RenderPassBeginInfo const *>(&rhs);
return *this;
}
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<RenderPassBeginInfo>::value, "struct wrapper is not a standard layout!" );
SubpassDescription( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSubpassDescription*>(this) = rhs;
+ *this = rhs;
}
SubpassDescription& operator=( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSubpassDescription*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SubpassDescription const *>(&rhs);
return *this;
}
SubpassDependency( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSubpassDependency*>(this) = rhs;
+ *this = rhs;
}
SubpassDependency& operator=( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSubpassDependency*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SubpassDependency const *>(&rhs);
return *this;
}
static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<SubpassDependency>::value, "struct wrapper is not a standard layout!" );
- 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<VkRenderPassCreateInfo*>(this) = rhs;
- }
-
- RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkRenderPassCreateInfo*>(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,
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<vk::RenderPassCreateInfo const *>(&rhs);
return *this;
}
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<RenderPassCreateInfo>::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<VkSubpassDescription2KHR*>(this) = rhs;
- }
-
- SubpassDescription2KHR& operator=( VkSubpassDescription2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSubpassDescription2KHR*>(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,
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<vk::SubpassDescription2KHR const *>(&rhs);
return *this;
}
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<SubpassDescription2KHR>::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<VkSubpassDependency2KHR*>(this) = rhs;
- }
-
- SubpassDependency2KHR& operator=( VkSubpassDependency2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSubpassDependency2KHR*>(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,
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<vk::SubpassDependency2KHR const *>(&rhs);
return *this;
}
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<SubpassDependency2KHR>::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<VkRenderPassCreateInfo2KHR*>(this) = rhs;
- }
-
- RenderPassCreateInfo2KHR& operator=( VkRenderPassCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkRenderPassCreateInfo2KHR*>(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,
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<vk::RenderPassCreateInfo2KHR const *>(&rhs);
return *this;
}
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<RenderPassCreateInfo2KHR>::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<VkRenderPassFragmentDensityMapCreateInfoEXT*>(this) = rhs;
- }
-
- RenderPassFragmentDensityMapCreateInfoEXT& operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(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<vk::RenderPassFragmentDensityMapCreateInfoEXT const *>(&rhs);
return *this;
}
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<RenderPassFragmentDensityMapCreateInfoEXT>::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<VkRenderPassInputAttachmentAspectCreateInfo*>(this) = rhs;
- }
-
- RenderPassInputAttachmentAspectCreateInfo& operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(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<vk::RenderPassInputAttachmentAspectCreateInfo const *>(&rhs);
return *this;
}
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<RenderPassInputAttachmentAspectCreateInfo>::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<VkRenderPassMultiviewCreateInfo*>(this) = rhs;
- }
-
- RenderPassMultiviewCreateInfo& operator=( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(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,
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<vk::RenderPassMultiviewCreateInfo const *>(&rhs);
return *this;
}
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<RenderPassMultiviewCreateInfo>::value, "struct wrapper is not a standard layout!" );
SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSubpassSampleLocationsEXT*>(this) = rhs;
+ *this = rhs;
}
SubpassSampleLocationsEXT& operator=( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSubpassSampleLocationsEXT*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SubpassSampleLocationsEXT const *>(&rhs);
return *this;
}
static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<SubpassSampleLocationsEXT>::value, "struct wrapper is not a standard layout!" );
- 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<VkRenderPassSampleLocationsBeginInfoEXT*>(this) = rhs;
- }
-
- RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(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<vk::RenderPassSampleLocationsBeginInfoEXT const *>(&rhs);
return *this;
}
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<RenderPassSampleLocationsBeginInfoEXT>::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<VkSamplerCreateInfo*>(this) = rhs;
- }
-
- SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSamplerCreateInfo*>(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,
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<vk::SamplerCreateInfo const *>(&rhs);
return *this;
}
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<SamplerCreateInfo>::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<VkSamplerReductionModeCreateInfoEXT*>(this) = rhs;
- }
-
- SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(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<vk::SamplerReductionModeCreateInfoEXT const *>(&rhs);
return *this;
}
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<SamplerReductionModeCreateInfoEXT>::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<VkSamplerYcbcrConversionCreateInfo*>(this) = rhs;
- }
-
- SamplerYcbcrConversionCreateInfo& operator=( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>(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,
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<vk::SamplerYcbcrConversionCreateInfo const *>(&rhs);
return *this;
}
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<SamplerYcbcrConversionCreateInfo>::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<VkSamplerYcbcrConversionImageFormatProperties*>(this) = rhs;
- }
-
- SamplerYcbcrConversionImageFormatProperties& operator=( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(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<vk::SamplerYcbcrConversionImageFormatProperties const *>(&rhs);
return *this;
}
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<SamplerYcbcrConversionImageFormatProperties>::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<VkSamplerYcbcrConversionInfo*>(this) = rhs;
- }
-
- SamplerYcbcrConversionInfo& operator=( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSamplerYcbcrConversionInfo*>(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<vk::SamplerYcbcrConversionInfo const *>(&rhs);
return *this;
}
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<SamplerYcbcrConversionInfo>::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<VkSemaphoreCreateInfo*>(this) = rhs;
- }
-
- SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSemaphoreCreateInfo*>(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<vk::SemaphoreCreateInfo const *>(&rhs);
return *this;
}
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<SemaphoreCreateInfo>::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<VkSemaphoreGetFdInfoKHR*>(this) = rhs;
- }
-
- SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSemaphoreGetFdInfoKHR*>(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<vk::SemaphoreGetFdInfoKHR const *>(&rhs);
return *this;
}
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<SemaphoreGetFdInfoKHR>::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<VkSemaphoreGetWin32HandleInfoKHR*>(this) = rhs;
- }
-
- SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>(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<vk::SemaphoreGetWin32HandleInfoKHR const *>(&rhs);
return *this;
}
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<SemaphoreGetWin32HandleInfoKHR>::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<VkSemaphoreSignalInfoKHR*>(this) = rhs;
- }
-
- SemaphoreSignalInfoKHR& operator=( VkSemaphoreSignalInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSemaphoreSignalInfoKHR*>(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<vk::SemaphoreSignalInfoKHR const *>(&rhs);
return *this;
}
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<SemaphoreSignalInfoKHR>::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<VkSemaphoreTypeCreateInfoKHR*>(this) = rhs;
- }
-
- SemaphoreTypeCreateInfoKHR& operator=( VkSemaphoreTypeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSemaphoreTypeCreateInfoKHR*>(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<vk::SemaphoreTypeCreateInfoKHR const *>(&rhs);
return *this;
}
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<SemaphoreTypeCreateInfoKHR>::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<VkSemaphoreWaitInfoKHR*>(this) = rhs;
- }
-
- SemaphoreWaitInfoKHR& operator=( VkSemaphoreWaitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSemaphoreWaitInfoKHR*>(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<vk::SemaphoreWaitInfoKHR const *>(&rhs);
return *this;
}
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<SemaphoreWaitInfoKHR>::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<VkShaderModuleCreateInfo*>(this) = rhs;
- }
-
- ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkShaderModuleCreateInfo*>(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<vk::ShaderModuleCreateInfo const *>(&rhs);
return *this;
}
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<ShaderModuleCreateInfo>::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<VkShaderModuleValidationCacheCreateInfoEXT*>(this) = rhs;
- }
-
- ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(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<vk::ShaderModuleValidationCacheCreateInfoEXT const *>(&rhs);
return *this;
}
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<ShaderModuleValidationCacheCreateInfoEXT>::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<VkShaderResourceUsageAMD*>(this) = rhs;
+ *this = rhs;
}
ShaderResourceUsageAMD& operator=( VkShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkShaderResourceUsageAMD*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ShaderResourceUsageAMD const *>(&rhs);
return *this;
}
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<uint32_t,3> const& computeWorkGroupSize_ = { { 0 } } ) VULKAN_HPP_NOEXCEPT
+ : shaderStageMask( shaderStageMask_ )
+ , resourceUsage( resourceUsage_ )
+ , numPhysicalVgprs( numPhysicalVgprs_ )
+ , numPhysicalSgprs( numPhysicalSgprs_ )
+ , numAvailableVgprs( numAvailableVgprs_ )
+ , numAvailableSgprs( numAvailableSgprs_ )
+ , computeWorkGroupSize{}
+ {
+ vk::ConstExpressionArrayCopy<uint32_t,3,3>::copy( computeWorkGroupSize, computeWorkGroupSize_ );
+ }
ShaderStatisticsInfoAMD( VkShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkShaderStatisticsInfoAMD*>(this) = rhs;
+ *this = rhs;
}
ShaderStatisticsInfoAMD& operator=( VkShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkShaderStatisticsInfoAMD*>(this) = rhs;
+ *this = *reinterpret_cast<vk::ShaderStatisticsInfoAMD const *>(&rhs);
return *this;
}
static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<ShaderStatisticsInfoAMD>::value, "struct wrapper is not a standard layout!" );
- namespace layout
+ struct SharedPresentSurfaceCapabilitiesKHR
{
- struct SharedPresentSurfaceCapabilitiesKHR
- {
- protected:
- SharedPresentSurfaceCapabilitiesKHR() VULKAN_HPP_NOEXCEPT
- {}
-
- SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(this) = rhs;
- }
-
- SharedPresentSurfaceCapabilitiesKHR& operator=( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(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<vk::SharedPresentSurfaceCapabilitiesKHR const *>(&rhs);
return *this;
}
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<SharedPresentSurfaceCapabilitiesKHR>::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<VkSparseImageFormatProperties*>(this) = rhs;
+ *this = rhs;
}
SparseImageFormatProperties& operator=( VkSparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSparseImageFormatProperties*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SparseImageFormatProperties const *>(&rhs);
return *this;
}
static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<SparseImageFormatProperties>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct SparseImageFormatProperties2
- {
- protected:
- SparseImageFormatProperties2() VULKAN_HPP_NOEXCEPT
- {}
-
- SparseImageFormatProperties2( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSparseImageFormatProperties2*>(this) = rhs;
- }
-
- SparseImageFormatProperties2& operator=( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSparseImageFormatProperties2*>(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
+ struct 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<vk::SparseImageFormatProperties2 const *>(&rhs);
return *this;
}
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<SparseImageFormatProperties2>::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<VkSparseImageMemoryRequirements*>(this) = rhs;
+ *this = rhs;
}
SparseImageMemoryRequirements& operator=( VkSparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSparseImageMemoryRequirements*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SparseImageMemoryRequirements const *>(&rhs);
return *this;
}
static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<SparseImageMemoryRequirements>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct SparseImageMemoryRequirements2
- {
- protected:
- SparseImageMemoryRequirements2() VULKAN_HPP_NOEXCEPT
- {}
-
- SparseImageMemoryRequirements2( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSparseImageMemoryRequirements2*>(this) = rhs;
- }
-
- SparseImageMemoryRequirements2& operator=( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSparseImageMemoryRequirements2*>(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
+ struct 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<vk::SparseImageMemoryRequirements2 const *>(&rhs);
return *this;
}
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<SparseImageMemoryRequirements2>::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<VkStreamDescriptorSurfaceCreateInfoGGP*>(this) = rhs;
- }
-
- StreamDescriptorSurfaceCreateInfoGGP& operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP*>(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<vk::StreamDescriptorSurfaceCreateInfoGGP const *>(&rhs);
return *this;
}
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<StreamDescriptorSurfaceCreateInfoGGP>::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<VkSubmitInfo*>(this) = rhs;
- }
-
- SubmitInfo& operator=( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSubmitInfo*>(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,
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<vk::SubmitInfo const *>(&rhs);
return *this;
}
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<SubmitInfo>::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<VkSubpassBeginInfoKHR*>(this) = rhs;
- }
-
- SubpassBeginInfoKHR& operator=( VkSubpassBeginInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSubpassBeginInfoKHR*>(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<vk::SubpassBeginInfoKHR const *>(&rhs);
return *this;
}
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<SubpassBeginInfoKHR>::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<VkSubpassDescriptionDepthStencilResolveKHR*>(this) = rhs;
- }
-
- SubpassDescriptionDepthStencilResolveKHR& operator=( VkSubpassDescriptionDepthStencilResolveKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSubpassDescriptionDepthStencilResolveKHR*>(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<vk::SubpassDescriptionDepthStencilResolveKHR const *>(&rhs);
return *this;
}
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<SubpassDescriptionDepthStencilResolveKHR>::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<VkSubpassEndInfoKHR*>(this) = rhs;
- }
-
- SubpassEndInfoKHR& operator=( VkSubpassEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSubpassEndInfoKHR*>(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<vk::SubpassEndInfoKHR const *>(&rhs);
return *this;
}
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<SubpassEndInfoKHR>::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<VkSurfaceCapabilities2EXT*>(this) = rhs;
- }
-
- SurfaceCapabilities2EXT& operator=( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSurfaceCapabilities2EXT*>(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<vk::SurfaceCapabilities2EXT const *>(&rhs);
return *this;
}
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<SurfaceCapabilities2EXT>::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<VkSurfaceCapabilitiesKHR*>(this) = rhs;
+ *this = rhs;
}
SurfaceCapabilitiesKHR& operator=( VkSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSurfaceCapabilitiesKHR*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SurfaceCapabilitiesKHR const *>(&rhs);
return *this;
}
static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<SurfaceCapabilitiesKHR>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct SurfaceCapabilities2KHR
- {
- protected:
- SurfaceCapabilities2KHR() VULKAN_HPP_NOEXCEPT
- {}
-
- SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSurfaceCapabilities2KHR*>(this) = rhs;
- }
-
- SurfaceCapabilities2KHR& operator=( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSurfaceCapabilities2KHR*>(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
+ struct 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<vk::SurfaceCapabilities2KHR const *>(&rhs);
return *this;
}
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<SurfaceCapabilities2KHR>::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<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(this) = rhs;
- }
-
- SurfaceCapabilitiesFullScreenExclusiveEXT& operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(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<vk::SurfaceCapabilitiesFullScreenExclusiveEXT const *>(&rhs);
return *this;
}
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<SurfaceCapabilitiesFullScreenExclusiveEXT>::value, "struct wrapper is not a standard layout!" );
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<VkSurfaceFormatKHR*>(this) = rhs;
+ *this = rhs;
}
SurfaceFormatKHR& operator=( VkSurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
- *reinterpret_cast<VkSurfaceFormatKHR*>(this) = rhs;
+ *this = *reinterpret_cast<vk::SurfaceFormatKHR const *>(&rhs);
return *this;
}
static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" );
static_assert( std::is_standard_layout<SurfaceFormatKHR>::value, "struct wrapper is not a standard layout!" );
- namespace layout
+ struct SurfaceFormat2KHR
{
- struct SurfaceFormat2KHR
- {
- protected:
- SurfaceFormat2KHR() VULKAN_HPP_NOEXCEPT
- {}
-
- SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSurfaceFormat2KHR*>(this) = rhs;
- }
-
- SurfaceFormat2KHR& operator=( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSurfaceFormat2KHR*>(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<vk::SurfaceFormat2KHR const *>(&rhs);
return *this;
}
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<SurfaceFormat2KHR>::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<VkSurfaceFullScreenExclusiveInfoEXT*>(this) = rhs;
- }
-
- SurfaceFullScreenExclusiveInfoEXT& operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(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<vk::SurfaceFullScreenExclusiveInfoEXT const *>(&rhs);
return *this;
}
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<SurfaceFullScreenExclusiveInfoEXT>::value, "struct wrapper is not a standard layout!" );
#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<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(this) = rhs;
- }
-
- SurfaceFullScreenExclusiveWin32InfoEXT& operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(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<vk::SurfaceFullScreenExclusiveWin32InfoEXT const *>(&rhs);
return *this;
}
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<SurfaceFullScreenExclusiveWin32InfoEXT>::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<VkSurfaceProtectedCapabilitiesKHR*>(this) = rhs;
- }
-
- SurfaceProtectedCapabilitiesKHR& operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(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<vk::SurfaceProtectedCapabilitiesKHR const *>(&rhs);
return *this;
}
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<SurfaceProtectedCapabilitiesKHR>::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<VkSwapchainCounterCreateInfoEXT*>(this) = rhs;
- }
-
- SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(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<vk::SwapchainCounterCreateInfoEXT const *>(&rhs);
return *this;
}
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<SwapchainCounterCreateInfoEXT>::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<VkSwapchainCreateInfoKHR*>(this) = rhs;
- }
-
- SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSwapchainCreateInfoKHR*>(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(),
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<vk::SwapchainCreateInfoKHR const *>(&rhs);
return *this;
}
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<SwapchainCreateInfoKHR>::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<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(this) = rhs;
- }
-
- SwapchainDisplayNativeHdrCreateInfoAMD& operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(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<vk::SwapchainDisplayNativeHdrCreateInfoAMD const *>(&rhs);
return *this;
}
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<SwapchainDisplayNativeHdrCreateInfoAMD>::value, "struct wrapper is not a standard layout!" );
- namespace layout
- {
- struct TextureLODGatherFormatPropertiesAMD
- {
- protected:
- TextureLODGatherFormatPropertiesAMD() VULKAN_HPP_NOEXCEPT
- {}
-
- TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(this) = rhs;
- }
-
- TextureLODGatherFormatPropertiesAMD& operator=( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(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
+ struct 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<vk::TextureLODGatherFormatPropertiesAMD const *>(&rhs);
return *this;
}
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<TextureLODGatherFormatPropertiesAMD>::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<VkTimelineSemaphoreSubmitInfoKHR*>(this) = rhs;
- }
-
- TimelineSemaphoreSubmitInfoKHR& operator=( VkTimelineSemaphoreSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkTimelineSemaphoreSubmitInfoKHR*>(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<vk::TimelineSemaphoreSubmitInfoKHR const *>(&rhs);
return *this;
}
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<TimelineSemaphoreSubmitInfoKHR>::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<VkValidationCacheCreateInfoEXT*>(this) = rhs;
- }
-
- ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkValidationCacheCreateInfoEXT*>(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<vk::ValidationCacheCreateInfoEXT const *>(&rhs);
return *this;
}
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<ValidationCacheCreateInfoEXT>::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<VkValidationFeaturesEXT*>(this) = rhs;
- }
-
- ValidationFeaturesEXT& operator=( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkValidationFeaturesEXT*>(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<vk::ValidationFeaturesEXT const *>(&rhs);
return *this;
}
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<ValidationFeaturesEXT>::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<VkValidationFlagsEXT*>(this) = rhs;
- }
-
- ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkValidationFlagsEXT*>(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<vk::ValidationFlagsEXT const *>(&rhs);
return *this;
}
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<ValidationFlagsEXT>::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<VkViSurfaceCreateInfoNN*>(this) = rhs;
- }
-
- ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkViSurfaceCreateInfoNN*>(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<vk::ViSurfaceCreateInfoNN const *>(&rhs);
return *this;
}
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<ViSurfaceCreateInfoNN>::value, "struct wrapper is not a standard layout!" );
#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<VkWaylandSurfaceCreateInfoKHR*>(this) = rhs;
- }
-
- WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR*>(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<vk::WaylandSurfaceCreateInfoKHR const *>(&rhs);
return *this;
}
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<WaylandSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
#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<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this) = rhs;
- }
-
- Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(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,
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<vk::Win32KeyedMutexAcquireReleaseInfoKHR const *>(&rhs);
return *this;
}
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<Win32KeyedMutexAcquireReleaseInfoKHR>::value, "struct wrapper is not a standard layout!" );
#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<VkWin32KeyedMutexAcquireReleaseInfoNV*>(this) = rhs;
- }
-
- Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(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,
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<vk::Win32KeyedMutexAcquireReleaseInfoNV const *>(&rhs);
return *this;
}
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<Win32KeyedMutexAcquireReleaseInfoNV>::value, "struct wrapper is not a standard layout!" );
#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<VkWin32SurfaceCreateInfoKHR*>(this) = rhs;
- }
-
- Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkWin32SurfaceCreateInfoKHR*>(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<vk::Win32SurfaceCreateInfoKHR const *>(&rhs);
return *this;
}
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<Win32SurfaceCreateInfoKHR>::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<VkWriteDescriptorSet*>(this) = rhs;
- }
-
- WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkWriteDescriptorSet*>(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,
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<vk::WriteDescriptorSet const *>(&rhs);
return *this;
}
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<WriteDescriptorSet>::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<VkWriteDescriptorSetAccelerationStructureNV*>(this) = rhs;
- }
-
- WriteDescriptorSetAccelerationStructureNV& operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(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<vk::WriteDescriptorSetAccelerationStructureNV const *>(&rhs);
return *this;
}
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<WriteDescriptorSetAccelerationStructureNV>::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<VkWriteDescriptorSetInlineUniformBlockEXT*>(this) = rhs;
- }
-
- WriteDescriptorSetInlineUniformBlockEXT& operator=( VkWriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(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<vk::WriteDescriptorSetInlineUniformBlockEXT const *>(&rhs);
return *this;
}
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<WriteDescriptorSetInlineUniformBlockEXT>::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<VkXcbSurfaceCreateInfoKHR*>(this) = rhs;
- }
-
- XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkXcbSurfaceCreateInfoKHR*>(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<vk::XcbSurfaceCreateInfoKHR const *>(&rhs);
return *this;
}
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<XcbSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
#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<VkXlibSurfaceCreateInfoKHR*>(this) = rhs;
- }
-
- XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
- {
- *reinterpret_cast<VkXlibSurfaceCreateInfoKHR*>(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<vk::XlibSurfaceCreateInfoKHR const *>(&rhs);
return *this;
}
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<XlibSurfaceCreateInfoKHR>::value, "struct wrapper is not a standard layout!" );
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
+ VULKAN_HPP_INLINE Result Device::acquireProfilingLockKHR( const vk::AcquireProfilingLockInfoKHR* pInfo, Dispatch const &d) const
+ {
+ return static_cast<Result>( d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR*>( pInfo ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE ResultValueType<void>::type Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const &d ) const
+ {
+ Result result = static_cast<Result>( d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast<const VkAcquireProfilingLockInfoKHR*>( &info ) ) );
+ return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::acquireProfilingLockKHR" );
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const vk::CommandBufferAllocateInfo* pAllocateInfo, vk::CommandBuffer* pCommandBuffers, Dispatch const &d) const
{
return static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkCommandBuffer*>( pCommandBuffers ) ) );
Result result = static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( &deviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerEventEXT" );
}
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type Device::registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ {
+ vk::Fence fence;
+ Result result = static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( &deviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
+
+ ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+ return createResultValue<Fence,Dispatch>( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerEventEXTUnique", deleter );
+ }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
Result result = static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( &displayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerDisplayEventEXT" );
}
+#ifndef VULKAN_HPP_NO_SMART_HANDLE
+ template<typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type Device::registerDisplayEventEXTUnique( vk::DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
+ {
+ vk::Fence fence;
+ Result result = static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( &displayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
+
+ ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
+ return createResultValue<Fence,Dispatch>( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerDisplayEventEXTUnique", deleter );
+ }
+#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template<typename Dispatch>
+ VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR(Dispatch const &d) const VULKAN_HPP_NOEXCEPT
+ {
+ d.vkReleaseProfilingLockKHR( m_device );
+ }
+#else
+ template<typename Dispatch>
+ 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<typename Dispatch>
VULKAN_HPP_INLINE Result Device::resetCommandPool( vk::CommandPool commandPool, vk::CommandPoolResetFlags flags, Dispatch const &d) const
{
return static_cast<Result>( d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
+ 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<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, pCounterCount, reinterpret_cast<VkPerformanceCounterKHR*>( pCounters ), reinterpret_cast<VkPerformanceCounterDescriptionKHR*>( pCounterDescriptions ) ) );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR,Allocator>>::type PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, ArrayProxy<vk::PerformanceCounterKHR> counters, Dispatch const &d ) const
+ {
+ std::vector<PerformanceCounterDescriptionKHR,Allocator> counterDescriptions;
+ uint32_t counterCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, counters.size() , reinterpret_cast<VkPerformanceCounterKHR*>( counters.data() ), nullptr ) );
+ if ( ( result == Result::eSuccess ) && counterCount )
+ {
+ counterDescriptions.resize( counterCount );
+ result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, counters.size() , reinterpret_cast<VkPerformanceCounterKHR*>( counters.data() ), reinterpret_cast<VkPerformanceCounterDescriptionKHR*>( 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<typename Allocator, typename Dispatch>
+ VULKAN_HPP_INLINE typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR,Allocator>>::type PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, ArrayProxy<vk::PerformanceCounterKHR> counters, Allocator const& vectorAllocator, Dispatch const &d ) const
+ {
+ std::vector<PerformanceCounterDescriptionKHR,Allocator> counterDescriptions( vectorAllocator );
+ uint32_t counterCount;
+ Result result;
+ do
+ {
+ result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, counters.size() , reinterpret_cast<VkPerformanceCounterKHR*>( counters.data() ), nullptr ) );
+ if ( ( result == Result::eSuccess ) && counterCount )
+ {
+ counterDescriptions.resize( counterCount );
+ result = static_cast<Result>( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, counters.size() , reinterpret_cast<VkPerformanceCounterKHR*>( counters.data() ), reinterpret_cast<VkPerformanceCounterDescriptionKHR*>( 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<typename Dispatch>
VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModeProperties2KHR( vk::DisplayKHR display, uint32_t* pPropertyCount, vk::DisplayModeProperties2KHR* pProperties, Dispatch const &d) const
{
return static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModeProperties2KHR*>( pProperties ) ) );
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template<typename Dispatch>
+ 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<const VkQueryPoolPerformanceCreateInfoKHR*>( pPerformanceQueryCreateInfo ), pNumPasses );
+ }
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+ template<typename Dispatch>
+ 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<const VkQueryPoolPerformanceCreateInfoKHR*>( &performanceQueryCreateInfo ), &numPasses );
+ return numPasses;
+ }
+#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+ template<typename Dispatch>
VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, vk::QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d) const VULKAN_HPP_NOEXCEPT
{
d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( pQueueFamilyProperties ) );
uint32_t queueFamilyPropertyCount;
d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
queueFamilyProperties.resize( queueFamilyPropertyCount );
- d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+ std::vector<vk::QueueFamilyProperties2> localVector( queueFamilyPropertyCount );
+ for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+ {
+ localVector[i].pNext = queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>().pNext;
+ }
+ d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
+ for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+ {
+ queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>() = localVector[i];
+ }
return queueFamilyProperties;
}
template<typename StructureChain, typename Allocator, typename Dispatch>
uint32_t queueFamilyPropertyCount;
d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
queueFamilyProperties.resize( queueFamilyPropertyCount );
- d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+ std::vector<vk::QueueFamilyProperties2> localVector( queueFamilyPropertyCount );
+ for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+ {
+ localVector[i].pNext = queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>().pNext;
+ }
+ d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
+ for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+ {
+ queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>() = localVector[i];
+ }
return queueFamilyProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
uint32_t queueFamilyPropertyCount;
d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
queueFamilyProperties.resize( queueFamilyPropertyCount );
- d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+ std::vector<vk::QueueFamilyProperties2> localVector( queueFamilyPropertyCount );
+ for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+ {
+ localVector[i].pNext = queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>().pNext;
+ }
+ d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
+ for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+ {
+ queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>() = localVector[i];
+ }
return queueFamilyProperties;
}
template<typename StructureChain, typename Allocator, typename Dispatch>
uint32_t queueFamilyPropertyCount;
d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
queueFamilyProperties.resize( queueFamilyPropertyCount );
- d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
+ std::vector<vk::QueueFamilyProperties2> localVector( queueFamilyPropertyCount );
+ for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+ {
+ localVector[i].pNext = queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>().pNext;
+ }
+ d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( localVector.data() ) );
+ for ( uint32_t i = 0; i < queueFamilyPropertyCount ; i++ )
+ {
+ queueFamilyProperties[i].template get<vk::QueueFamilyProperties2>() = localVector[i];
+ }
return queueFamilyProperties;
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <> struct isStructureChainValid<MemoryAllocateInfo, MemoryDedicatedAllocateInfo>{ enum { value = true }; };
template <> struct isStructureChainValid<MemoryRequirements2, MemoryDedicatedRequirements>{ enum { value = true }; };
template <> struct isStructureChainValid<MemoryAllocateInfo, MemoryPriorityAllocateInfoEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<SubmitInfo, PerformanceQuerySubmitInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDevice16BitStorageFeatures>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDevice16BitStorageFeatures>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDevice8BitStorageFeaturesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDeviceMultiviewProperties>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePCIBusInfoPropertiesEXT>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDevicePerformanceQueryFeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDevicePerformanceQueryFeaturesKHR>{ enum { value = true }; };
+ template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePerformanceQueryPropertiesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceFeatures2, PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PhysicalDeviceProperties2, PhysicalDevicePointClippingProperties>{ enum { value = true }; };
template <> struct isStructureChainValid<PresentInfoKHR, PresentRegionsKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<PresentInfoKHR, PresentTimesInfoGOOGLE>{ enum { value = true }; };
template <> struct isStructureChainValid<SubmitInfo, ProtectedSubmitInfo>{ enum { value = true }; };
+ template <> struct isStructureChainValid<QueryPoolCreateInfo, QueryPoolPerformanceCreateInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<QueueFamilyProperties2, QueueFamilyCheckpointPropertiesNV>{ enum { value = true }; };
template <> struct isStructureChainValid<RenderPassBeginInfo, RenderPassAttachmentBeginInfoKHR>{ enum { value = true }; };
template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassFragmentDensityMapCreateInfoEXT>{ enum { value = true }; };
template <> struct isStructureChainValid<WriteDescriptorSet, WriteDescriptorSetAccelerationStructureNV>{ enum { value = true }; };
template <> struct isStructureChainValid<WriteDescriptorSet, WriteDescriptorSetInlineUniformBlockEXT>{ 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
{
#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
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;
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;
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;
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;
}
}
- void init( vk::Instance instance ) VULKAN_HPP_NOEXCEPT
+ void init( vk::Instance instanceCpp ) VULKAN_HPP_NOEXCEPT
{
+ VkInstance instance = static_cast<VkInstance>(instanceCpp);
#ifdef VK_USE_PLATFORM_ANDROID_KHR
vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) );
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
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" ) );
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" ) );
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" ) );
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" ) );
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<VkDevice>(deviceCpp);
vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) );
vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) );
vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) );
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" ) );
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" ) );
projects / platform / upstream / Vulkan-Headers.git / commitdiff