mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-10-14 16:32:17 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Update Vulkan-Headers to v1.3.256 (#1609)

Browse Source 
Co-authored-by: GitHub <noreply@github.com>
This commit is contained in:
github-actions[bot] 2023-07-03 12:07:37 +02:00 committed by GitHub
parent 2613539ff4
commit c115fd1ec6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 1771 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Vulkan-Headers

@ -1 +1 @@
Subproject commit b6a29e5ca865f48368f6b2f170adb89975bb0be1 Subproject commit ed857118e243fdc0f3a100f00ac9919e874cfe63

2
vulkan/vulkan.hpp
View File

@ -114,7 +114,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span> # include <span>
#endif #endif
static_assert( VK_HEADER_VERSION == 255, "Wrong VK_HEADER_VERSION!" ); static_assert( VK_HEADER_VERSION == 256, "Wrong VK_HEADER_VERSION!" );
// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default. // 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION

3
vulkan/vulkan_enums.hpp
View File

@ -3755,6 +3755,7 @@ namespace VULKAN_HPP_NAMESPACE
eMeshShaderNV = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV, eMeshShaderNV = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV,
eTaskShaderEXT = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT, eTaskShaderEXT = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT,
eMeshShaderEXT = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT, eMeshShaderEXT = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT,
eSubpassShaderHUAWEI = VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI,
eSubpassShadingHUAWEI = VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI, eSubpassShadingHUAWEI = VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI,
eInvocationMaskHUAWEI = VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI, eInvocationMaskHUAWEI = VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI,
eAccelerationStructureCopyKHR = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR, eAccelerationStructureCopyKHR = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR,
@ -3786,7 +3787,7 @@ namespace VULKAN_HPP_NAMESPACE
| PipelineStageFlagBits2::eTransformFeedbackEXT | PipelineStageFlagBits2::eConditionalRenderingEXT | PipelineStageFlagBits2::eCommandPreprocessNV | | PipelineStageFlagBits2::eTransformFeedbackEXT | PipelineStageFlagBits2::eConditionalRenderingEXT | PipelineStageFlagBits2::eCommandPreprocessNV |
PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR | PipelineStageFlagBits2::eAccelerationStructureBuildKHR | PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR | PipelineStageFlagBits2::eAccelerationStructureBuildKHR |
PipelineStageFlagBits2::eRayTracingShaderKHR | PipelineStageFlagBits2::eFragmentDensityProcessEXT | PipelineStageFlagBits2::eTaskShaderEXT | PipelineStageFlagBits2::eRayTracingShaderKHR | PipelineStageFlagBits2::eFragmentDensityProcessEXT | PipelineStageFlagBits2::eTaskShaderEXT |
PipelineStageFlagBits2::eMeshShaderEXT | PipelineStageFlagBits2::eSubpassShadingHUAWEI | PipelineStageFlagBits2::eInvocationMaskHUAWEI | PipelineStageFlagBits2::eMeshShaderEXT | PipelineStageFlagBits2::eSubpassShaderHUAWEI | PipelineStageFlagBits2::eInvocationMaskHUAWEI |
PipelineStageFlagBits2::eAccelerationStructureCopyKHR | PipelineStageFlagBits2::eMicromapBuildEXT | PipelineStageFlagBits2::eClusterCullingShaderHUAWEI | PipelineStageFlagBits2::eAccelerationStructureCopyKHR | PipelineStageFlagBits2::eMicromapBuildEXT | PipelineStageFlagBits2::eClusterCullingShaderHUAWEI |
PipelineStageFlagBits2::eOpticalFlowNV; PipelineStageFlagBits2::eOpticalFlowNV;
}; };

12
vulkan/vulkan_format_traits.hpp
View File

@ -3165,21 +3165,21 @@ namespace VULKAN_HPP_NAMESPACE
switch ( component ) switch ( component )
{ {
case 0: return "R"; case 0: return "R";
case 1: return "B"; case 1: return "G";
default: VULKAN_HPP_ASSERT( false ); return ""; default: VULKAN_HPP_ASSERT( false ); return "";
} }
case VULKAN_HPP_NAMESPACE::Format::eR64G64Sint: case VULKAN_HPP_NAMESPACE::Format::eR64G64Sint:
switch ( component ) switch ( component )
{ {
case 0: return "R"; case 0: return "R";
case 1: return "B"; case 1: return "G";
default: VULKAN_HPP_ASSERT( false ); return ""; default: VULKAN_HPP_ASSERT( false ); return "";
} }
case VULKAN_HPP_NAMESPACE::Format::eR64G64Sfloat: case VULKAN_HPP_NAMESPACE::Format::eR64G64Sfloat:
switch ( component ) switch ( component )
{ {
case 0: return "R"; case 0: return "R";
case 1: return "B"; case 1: return "G";
default: VULKAN_HPP_ASSERT( false ); return ""; default: VULKAN_HPP_ASSERT( false ); return "";
} }
case VULKAN_HPP_NAMESPACE::Format::eR64G64B64Uint: case VULKAN_HPP_NAMESPACE::Format::eR64G64B64Uint:
@ -5393,7 +5393,7 @@ namespace VULKAN_HPP_NAMESPACE
case VULKAN_HPP_NAMESPACE::Format::eBc4SnormBlock: case VULKAN_HPP_NAMESPACE::Format::eBc4SnormBlock:
switch ( component ) switch ( component )
{ {
case 0: return "SRGB"; case 0: return "SNORM";
default: VULKAN_HPP_ASSERT( false ); return ""; default: VULKAN_HPP_ASSERT( false ); return "";
} }
case VULKAN_HPP_NAMESPACE::Format::eBc5UnormBlock: case VULKAN_HPP_NAMESPACE::Format::eBc5UnormBlock:
@ -5406,8 +5406,8 @@ namespace VULKAN_HPP_NAMESPACE
case VULKAN_HPP_NAMESPACE::Format::eBc5SnormBlock: case VULKAN_HPP_NAMESPACE::Format::eBc5SnormBlock:
switch ( component ) switch ( component )
{ {
case 0: return "SRGB"; case 0: return "SNORM";
case 1: return "SRGB"; case 1: return "SNORM";
default: VULKAN_HPP_ASSERT( false ); return ""; default: VULKAN_HPP_ASSERT( false ); return "";
} }
case VULKAN_HPP_NAMESPACE::Format::eBc6HUfloatBlock: case VULKAN_HPP_NAMESPACE::Format::eBc6HUfloatBlock:

6
vulkan/vulkan_to_string.hpp
View File

@ -1590,8 +1590,8 @@ namespace VULKAN_HPP_NAMESPACE
result += "TaskShaderEXT | "; result += "TaskShaderEXT | ";
if ( value & PipelineStageFlagBits2::eMeshShaderEXT ) if ( value & PipelineStageFlagBits2::eMeshShaderEXT )
result += "MeshShaderEXT | "; result += "MeshShaderEXT | ";
if ( value & PipelineStageFlagBits2::eSubpassShadingHUAWEI ) if ( value & PipelineStageFlagBits2::eSubpassShaderHUAWEI )
result += "SubpassShadingHUAWEI | "; result += "SubpassShaderHUAWEI | ";
if ( value & PipelineStageFlagBits2::eInvocationMaskHUAWEI ) if ( value & PipelineStageFlagBits2::eInvocationMaskHUAWEI )
result += "InvocationMaskHUAWEI | "; result += "InvocationMaskHUAWEI | ";
if ( value & PipelineStageFlagBits2::eAccelerationStructureCopyKHR ) if ( value & PipelineStageFlagBits2::eAccelerationStructureCopyKHR )
@ -6278,7 +6278,7 @@ namespace VULKAN_HPP_NAMESPACE
case PipelineStageFlagBits2::eFragmentDensityProcessEXT: return "FragmentDensityProcessEXT"; case PipelineStageFlagBits2::eFragmentDensityProcessEXT: return "FragmentDensityProcessEXT";
case PipelineStageFlagBits2::eTaskShaderEXT: return "TaskShaderEXT"; case PipelineStageFlagBits2::eTaskShaderEXT: return "TaskShaderEXT";
case PipelineStageFlagBits2::eMeshShaderEXT: return "MeshShaderEXT"; case PipelineStageFlagBits2::eMeshShaderEXT: return "MeshShaderEXT";
case PipelineStageFlagBits2::eSubpassShadingHUAWEI: return "SubpassShadingHUAWEI"; case PipelineStageFlagBits2::eSubpassShaderHUAWEI: return "SubpassShaderHUAWEI";
case PipelineStageFlagBits2::eInvocationMaskHUAWEI: return "InvocationMaskHUAWEI"; case PipelineStageFlagBits2::eInvocationMaskHUAWEI: return "InvocationMaskHUAWEI";
case PipelineStageFlagBits2::eAccelerationStructureCopyKHR: return "AccelerationStructureCopyKHR"; case PipelineStageFlagBits2::eAccelerationStructureCopyKHR: return "AccelerationStructureCopyKHR";
case PipelineStageFlagBits2::eMicromapBuildEXT: return "MicromapBuildEXT"; case PipelineStageFlagBits2::eMicromapBuildEXT: return "MicromapBuildEXT";

1467
vulkan/vulkansc.cppm Normal file
View File

File diff suppressed because it is too large Load Diff

128
vulkan/vulkansc.hpp
View File

@ -3538,7 +3538,7 @@ namespace VULKAN_HPP_NAMESPACE
} }
extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic;
# else # else
static inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic() inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic()
{ {
static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls; static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls;
return dls; return dls;
@ -4092,9 +4092,9 @@ namespace VULKAN_HPP_NAMESPACE
} }
}; };
namespace namespace detail
{ {
[[noreturn]] void throwResultException( Result result, char const * message ) [[noreturn]] VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
{ {
switch ( result ) switch ( result )
{ {
@ -4126,7 +4126,7 @@ namespace VULKAN_HPP_NAMESPACE
default: throw SystemError( make_error_code( result ), message ); default: throw SystemError( make_error_code( result ), message );
} }
} }
} // namespace } // namespace detail
#endif #endif
template <typename T> template <typename T>
@ -4178,7 +4178,15 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple() VULKAN_HPP_DEPRECATED(
"asTuple() on an l-value is deprecated, as it implicitly moves the UniqueHandle out of the ResultValue. Use asTuple() on an r-value instead, requiring to explicitly move the UniqueHandle." )
std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple() &
{
return std::make_tuple( result, std::move( value ) );
}
std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple() &&
{ {
return std::make_tuple( result, std::move( value ) ); return std::make_tuple( result, std::move( value ) );
} }
@ -4200,7 +4208,15 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple() VULKAN_HPP_DEPRECATED(
"asTuple() on an l-value is deprecated, as it implicitly moves the UniqueHandle out of the ResultValue. Use asTuple() on an r-value instead, requiring to explicitly move the UniqueHandle." )
std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple() &
{
return std::make_tuple( result, std::move( value ) );
}
std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple() &&
{ {
return std::make_tuple( result, std::move( value ) ); return std::make_tuple( result, std::move( value ) );
} }
@ -4270,7 +4286,7 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
if ( result != Result::eSuccess ) if ( result != Result::eSuccess )
{ {
throwResultException( result, message ); detail::throwResultException( result, message );
} }
#endif #endif
} }
@ -4285,10 +4301,106 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
{ {
throwResultException( result, message ); detail::throwResultException( result, message );
} }
#endif #endif
} }
//=========================================
//=== CONSTEXPR CONSTANTs AND FUNCTIONs ===
//=========================================
VULKAN_HPP_CONSTEXPR uint32_t AttachmentUnused = VK_ATTACHMENT_UNUSED;
VULKAN_HPP_CONSTEXPR uint32_t False = VK_FALSE;
VULKAN_HPP_CONSTEXPR float LodClampNone = VK_LOD_CLAMP_NONE;
VULKAN_HPP_CONSTEXPR uint32_t LuidSize = VK_LUID_SIZE;
VULKAN_HPP_CONSTEXPR uint32_t MaxDescriptionSize = VK_MAX_DESCRIPTION_SIZE;
VULKAN_HPP_CONSTEXPR uint32_t MaxDeviceGroupSize = VK_MAX_DEVICE_GROUP_SIZE;
VULKAN_HPP_CONSTEXPR uint32_t MaxDriverInfoSize = VK_MAX_DRIVER_INFO_SIZE;
VULKAN_HPP_CONSTEXPR uint32_t MaxDriverNameSize = VK_MAX_DRIVER_NAME_SIZE;
VULKAN_HPP_CONSTEXPR uint32_t MaxExtensionNameSize = VK_MAX_EXTENSION_NAME_SIZE;
VULKAN_HPP_CONSTEXPR uint32_t MaxGlobalPrioritySizeKhr = VK_MAX_GLOBAL_PRIORITY_SIZE_KHR;
VULKAN_HPP_CONSTEXPR uint32_t MaxMemoryHeaps = VK_MAX_MEMORY_HEAPS;
VULKAN_HPP_CONSTEXPR uint32_t MaxMemoryTypes = VK_MAX_MEMORY_TYPES;
VULKAN_HPP_CONSTEXPR uint32_t MaxPhysicalDeviceNameSize = VK_MAX_PHYSICAL_DEVICE_NAME_SIZE;
VULKAN_HPP_CONSTEXPR uint32_t MaxShaderModuleIdentifierSizeExt = VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT;
VULKAN_HPP_CONSTEXPR uint32_t QueueFamilyExternal = VK_QUEUE_FAMILY_EXTERNAL;
VULKAN_HPP_CONSTEXPR uint32_t QueueFamilyForeignExt = VK_QUEUE_FAMILY_FOREIGN_EXT;
VULKAN_HPP_CONSTEXPR uint32_t QueueFamilyIgnored = VK_QUEUE_FAMILY_IGNORED;
VULKAN_HPP_CONSTEXPR uint32_t Remaining3DSlicesExt = VK_REMAINING_3D_SLICES_EXT;
VULKAN_HPP_CONSTEXPR uint32_t RemainingArrayLayers = VK_REMAINING_ARRAY_LAYERS;
VULKAN_HPP_CONSTEXPR uint32_t RemainingMipLevels = VK_REMAINING_MIP_LEVELS;
VULKAN_HPP_CONSTEXPR uint32_t ShaderUnusedKhr = VK_SHADER_UNUSED_KHR;
VULKAN_HPP_CONSTEXPR uint32_t SubpassExternal = VK_SUBPASS_EXTERNAL;
VULKAN_HPP_CONSTEXPR uint32_t True = VK_TRUE;
VULKAN_HPP_CONSTEXPR uint32_t UuidSize = VK_UUID_SIZE;
VULKAN_HPP_CONSTEXPR uint64_t WholeSize = VK_WHOLE_SIZE;
VULKAN_HPP_CONSTEXPR uint32_t HeaderVersion = VK_HEADER_VERSION;
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_CONSTEXPR uint32_t apiVersionMajor( T const version )
{
return ( ( (uint32_t)( version ) >> 22U ) & 0x7FU );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_CONSTEXPR uint32_t apiVersionMinor( T const version )
{
return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_CONSTEXPR uint32_t apiVersionPatch( T const version )
{
return ( (uint32_t)(version)&0xFFFU );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_CONSTEXPR uint32_t apiVersionVariant( T const version )
{
return ( (uint32_t)( version ) >> 29U );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_CONSTEXPR uint32_t makeApiVersion( T const variant, T const major, T const minor, T const patch )
{
return ( ( ( (uint32_t)( variant ) ) << 29U ) | ( ( (uint32_t)( major ) ) << 22U ) | ( ( (uint32_t)( minor ) ) << 12U ) | ( (uint32_t)( patch ) ) );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_MAKE_API_VERSION should be used instead." )
VULKAN_HPP_CONSTEXPR uint32_t makeVersion( T const major, T const minor, T const patch )
{
return ( ( ( (uint32_t)( major ) ) << 22U ) | ( ( (uint32_t)( minor ) ) << 12U ) | ( (uint32_t)( patch ) ) );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_API_VERSION_MAJOR should be used instead." )
VULKAN_HPP_CONSTEXPR uint32_t versionMajor( T const version )
{
return ( (uint32_t)( version ) >> 22U );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_API_VERSION_MINOR should be used instead." )
VULKAN_HPP_CONSTEXPR uint32_t versionMinor( T const version )
{
return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU );
}
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_API_VERSION_PATCH should be used instead." )
VULKAN_HPP_CONSTEXPR uint32_t versionPatch( T const version )
{
return ( (uint32_t)(version)&0xFFFU );
}
VULKAN_HPP_CONSTEXPR auto ApiVersion = makeApiVersion( 0, 1, 0, 0 );
VULKAN_HPP_CONSTEXPR auto ApiVersion10 = makeApiVersion( 0, 1, 0, 0 );
VULKAN_HPP_CONSTEXPR auto ApiVersion11 = makeApiVersion( 0, 1, 1, 0 );
VULKAN_HPP_CONSTEXPR auto ApiVersion12 = makeApiVersion( 0, 1, 2, 0 );
VULKAN_HPP_CONSTEXPR auto ApiVersion13 = makeApiVersion( 0, 1, 3, 0 );
VULKAN_HPP_CONSTEXPR auto HeaderVersionComplete = makeApiVersion( VKSC_API_VARIANT, 1, 0, VK_HEADER_VERSION );
} // namespace VULKAN_HPP_NAMESPACE } // namespace VULKAN_HPP_NAMESPACE
// clang-format off // clang-format off

12
vulkan/vulkansc_format_traits.hpp
View File

@ -3123,21 +3123,21 @@ namespace VULKAN_HPP_NAMESPACE
switch ( component ) switch ( component )
{ {
case 0: return "R"; case 0: return "R";
case 1: return "B"; case 1: return "G";
default: VULKAN_HPP_ASSERT( false ); return ""; default: VULKAN_HPP_ASSERT( false ); return "";
} }
case VULKAN_HPP_NAMESPACE::Format::eR64G64Sint: case VULKAN_HPP_NAMESPACE::Format::eR64G64Sint:
switch ( component ) switch ( component )
{ {
case 0: return "R"; case 0: return "R";
case 1: return "B"; case 1: return "G";
default: VULKAN_HPP_ASSERT( false ); return ""; default: VULKAN_HPP_ASSERT( false ); return "";
} }
case VULKAN_HPP_NAMESPACE::Format::eR64G64Sfloat: case VULKAN_HPP_NAMESPACE::Format::eR64G64Sfloat:
switch ( component ) switch ( component )
{ {
case 0: return "R"; case 0: return "R";
case 1: return "B"; case 1: return "G";
default: VULKAN_HPP_ASSERT( false ); return ""; default: VULKAN_HPP_ASSERT( false ); return "";
} }
case VULKAN_HPP_NAMESPACE::Format::eR64G64B64Uint: case VULKAN_HPP_NAMESPACE::Format::eR64G64B64Uint:
@ -5272,7 +5272,7 @@ namespace VULKAN_HPP_NAMESPACE
case VULKAN_HPP_NAMESPACE::Format::eBc4SnormBlock: case VULKAN_HPP_NAMESPACE::Format::eBc4SnormBlock:
switch ( component ) switch ( component )
{ {
case 0: return "SRGB"; case 0: return "SNORM";
default: VULKAN_HPP_ASSERT( false ); return ""; default: VULKAN_HPP_ASSERT( false ); return "";
} }
case VULKAN_HPP_NAMESPACE::Format::eBc5UnormBlock: case VULKAN_HPP_NAMESPACE::Format::eBc5UnormBlock:
@ -5285,8 +5285,8 @@ namespace VULKAN_HPP_NAMESPACE
case VULKAN_HPP_NAMESPACE::Format::eBc5SnormBlock: case VULKAN_HPP_NAMESPACE::Format::eBc5SnormBlock:
switch ( component ) switch ( component )
{ {
case 0: return "SRGB"; case 0: return "SNORM";
case 1: return "SRGB"; case 1: return "SNORM";
default: VULKAN_HPP_ASSERT( false ); return ""; default: VULKAN_HPP_ASSERT( false ); return "";
} }
case VULKAN_HPP_NAMESPACE::Format::eBc6HUfloatBlock: case VULKAN_HPP_NAMESPACE::Format::eBc6HUfloatBlock:

360
vulkan/vulkansc_raii.hpp
View File

@ -1201,7 +1201,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkInstance *>( &m_instance ) ) ); reinterpret_cast<VkInstance *>( &m_instance ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateInstance" ); detail::throwResultException( result, "vkCreateInstance" );
} }
m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher( context.getDispatcher()->vkGetInstanceProcAddr, m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher( context.getDispatcher()->vkGetInstanceProcAddr,
static_cast<VkInstance>( m_instance ) ) ); static_cast<VkInstance>( m_instance ) ) );
@ -1239,10 +1239,9 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_instance, rhs.m_instance );
m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher.reset( rhs.m_dispatcher.release() );
} }
return *this; return *this;
} }
@ -1364,8 +1363,8 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ); std::swap( m_physicalDevice, rhs.m_physicalDevice );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); std::swap( m_dispatcher, rhs.m_dispatcher );
} }
return *this; return *this;
} }
@ -1604,7 +1603,7 @@ namespace VULKAN_HPP_NAMESPACE
} }
else else
{ {
throwResultException( result, "vkEnumeratePhysicalDevices" ); detail::throwResultException( result, "vkEnumeratePhysicalDevices" );
} }
} }
@ -1639,7 +1638,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkDevice *>( &m_device ) ) ); reinterpret_cast<VkDevice *>( &m_device ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateDevice" ); detail::throwResultException( result, "vkCreateDevice" );
} }
m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher( physicalDevice.getDispatcher()->vkGetDeviceProcAddr, m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher( physicalDevice.getDispatcher()->vkGetDeviceProcAddr,
static_cast<VkDevice>( m_device ) ) ); static_cast<VkDevice>( m_device ) ) );
@ -1677,10 +1676,9 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher.reset( rhs.m_dispatcher.release() );
} }
return *this; return *this;
} }
@ -2066,7 +2064,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkBuffer *>( &m_buffer ) ) ); reinterpret_cast<VkBuffer *>( &m_buffer ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateBuffer" ); detail::throwResultException( result, "vkCreateBuffer" );
} }
} }
@ -2104,11 +2102,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_buffer, rhs.m_buffer );
m_buffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_buffer, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -2195,7 +2192,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkBufferView *>( &m_bufferView ) ) ); reinterpret_cast<VkBufferView *>( &m_bufferView ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateBufferView" ); detail::throwResultException( result, "vkCreateBufferView" );
} }
} }
@ -2233,11 +2230,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_bufferView, rhs.m_bufferView );
m_bufferView = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferView, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -2318,7 +2314,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkCommandPool *>( &m_commandPool ) ) ); reinterpret_cast<VkCommandPool *>( &m_commandPool ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateCommandPool" ); detail::throwResultException( result, "vkCreateCommandPool" );
} }
} }
@ -2356,11 +2352,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_commandPool, rhs.m_commandPool );
m_commandPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -2465,11 +2460,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_commandPool, rhs.m_commandPool );
m_commandPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ); std::swap( m_commandBuffer, rhs.m_commandBuffer );
m_commandBuffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandBuffer, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -2948,7 +2942,7 @@ namespace VULKAN_HPP_NAMESPACE
} }
else else
{ {
throwResultException( result, "vkAllocateCommandBuffers" ); detail::throwResultException( result, "vkAllocateCommandBuffers" );
} }
} }
@ -2985,7 +2979,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkDebugUtilsMessengerEXT *>( &m_messenger ) ) ); reinterpret_cast<VkDebugUtilsMessengerEXT *>( &m_messenger ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateDebugUtilsMessengerEXT" ); detail::throwResultException( result, "vkCreateDebugUtilsMessengerEXT" );
} }
} }
@ -3023,11 +3017,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_instance, rhs.m_instance );
m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ); std::swap( m_messenger, rhs.m_messenger );
m_messenger = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_messenger, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -3109,7 +3102,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkDescriptorPool *>( &m_descriptorPool ) ) ); reinterpret_cast<VkDescriptorPool *>( &m_descriptorPool ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateDescriptorPool" ); detail::throwResultException( result, "vkCreateDescriptorPool" );
} }
} }
@ -3147,11 +3140,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_descriptorPool, rhs.m_descriptorPool );
m_descriptorPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -3252,11 +3244,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_descriptorPool, rhs.m_descriptorPool );
m_descriptorPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ); std::swap( m_descriptorSet, rhs.m_descriptorSet );
m_descriptorSet = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSet, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -3335,7 +3326,7 @@ namespace VULKAN_HPP_NAMESPACE
} }
else else
{ {
throwResultException( result, "vkAllocateDescriptorSets" ); detail::throwResultException( result, "vkAllocateDescriptorSets" );
} }
} }
@ -3372,7 +3363,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkDescriptorSetLayout *>( &m_descriptorSetLayout ) ) ); reinterpret_cast<VkDescriptorSetLayout *>( &m_descriptorSetLayout ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateDescriptorSetLayout" ); detail::throwResultException( result, "vkCreateDescriptorSetLayout" );
} }
} }
@ -3410,11 +3401,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_descriptorSetLayout, rhs.m_descriptorSetLayout );
m_descriptorSetLayout = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -3496,7 +3486,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkDeviceMemory *>( &m_memory ) ) ); reinterpret_cast<VkDeviceMemory *>( &m_memory ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkAllocateMemory" ); detail::throwResultException( result, "vkAllocateMemory" );
} }
} }
@ -3534,11 +3524,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_memory, rhs.m_memory );
m_memory = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_memory, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -3643,10 +3632,9 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_physicalDevice, rhs.m_physicalDevice );
m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ); std::swap( m_display, rhs.m_display );
m_display = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -3741,7 +3729,7 @@ namespace VULKAN_HPP_NAMESPACE
} }
else else
{ {
throwResultException( result, "vkGetDisplayPlaneSupportedDisplaysKHR" ); detail::throwResultException( result, "vkGetDisplayPlaneSupportedDisplaysKHR" );
} }
} }
@ -3777,7 +3765,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkDisplayModeKHR *>( &m_displayModeKHR ) ) ); reinterpret_cast<VkDisplayModeKHR *>( &m_displayModeKHR ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateDisplayModeKHR" ); detail::throwResultException( result, "vkCreateDisplayModeKHR" );
} }
} }
@ -3815,9 +3803,9 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ); std::swap( m_physicalDevice, rhs.m_physicalDevice );
m_displayModeKHR = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ); std::swap( m_displayModeKHR, rhs.m_displayModeKHR );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); std::swap( m_dispatcher, rhs.m_dispatcher );
} }
return *this; return *this;
} }
@ -3888,7 +3876,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkEvent *>( &m_event ) ) ); reinterpret_cast<VkEvent *>( &m_event ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateEvent" ); detail::throwResultException( result, "vkCreateEvent" );
} }
} }
@ -3926,11 +3914,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_event, rhs.m_event );
m_event = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_event, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -4019,7 +4006,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkFence *>( &m_fence ) ) ); reinterpret_cast<VkFence *>( &m_fence ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateFence" ); detail::throwResultException( result, "vkCreateFence" );
} }
} }
@ -4037,7 +4024,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkFence *>( &m_fence ) ) ); reinterpret_cast<VkFence *>( &m_fence ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkRegisterDeviceEventEXT" ); detail::throwResultException( result, "vkRegisterDeviceEventEXT" );
} }
} }
@ -4057,7 +4044,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkFence *>( &m_fence ) ) ); reinterpret_cast<VkFence *>( &m_fence ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkRegisterDisplayEventEXT" ); detail::throwResultException( result, "vkRegisterDisplayEventEXT" );
} }
} }
@ -4095,11 +4082,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_fence, rhs.m_fence );
m_fence = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_fence, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -4184,7 +4170,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkFramebuffer *>( &m_framebuffer ) ) ); reinterpret_cast<VkFramebuffer *>( &m_framebuffer ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateFramebuffer" ); detail::throwResultException( result, "vkCreateFramebuffer" );
} }
} }
@ -4222,11 +4208,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_framebuffer, rhs.m_framebuffer );
m_framebuffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_framebuffer, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -4307,7 +4292,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkImage *>( &m_image ) ) ); reinterpret_cast<VkImage *>( &m_image ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateImage" ); detail::throwResultException( result, "vkCreateImage" );
} }
} }
@ -4345,11 +4330,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_image, rhs.m_image );
m_image = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_image, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -4443,7 +4427,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkImageView *>( &m_imageView ) ) ); reinterpret_cast<VkImageView *>( &m_imageView ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateImageView" ); detail::throwResultException( result, "vkCreateImageView" );
} }
} }
@ -4481,11 +4465,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_imageView, rhs.m_imageView );
m_imageView = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_imageView, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -4566,7 +4549,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkPipelineCache *>( &m_pipelineCache ) ) ); reinterpret_cast<VkPipelineCache *>( &m_pipelineCache ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreatePipelineCache" ); detail::throwResultException( result, "vkCreatePipelineCache" );
} }
} }
@ -4604,11 +4587,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_pipelineCache, rhs.m_pipelineCache );
m_pipelineCache = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineCache, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -4712,7 +4694,7 @@ namespace VULKAN_HPP_NAMESPACE
if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
{ {
throwResultException( m_constructorSuccessCode, "vkCreateComputePipelines" ); detail::throwResultException( m_constructorSuccessCode, "vkCreateComputePipelines" );
} }
} }
@ -4734,7 +4716,7 @@ namespace VULKAN_HPP_NAMESPACE
if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
{ {
throwResultException( m_constructorSuccessCode, "vkCreateGraphicsPipelines" ); detail::throwResultException( m_constructorSuccessCode, "vkCreateGraphicsPipelines" );
} }
} }
@ -4775,12 +4757,11 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_pipeline, rhs.m_pipeline );
m_pipeline = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipeline, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode );
m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -4873,7 +4854,7 @@ namespace VULKAN_HPP_NAMESPACE
} }
else else
{ {
throwResultException( result, "vkCreateComputePipelines" ); detail::throwResultException( result, "vkCreateComputePipelines" );
} }
} }
@ -4901,7 +4882,7 @@ namespace VULKAN_HPP_NAMESPACE
} }
else else
{ {
throwResultException( result, "vkCreateGraphicsPipelines" ); detail::throwResultException( result, "vkCreateGraphicsPipelines" );
} }
} }
@ -4938,7 +4919,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkPipelineLayout *>( &m_pipelineLayout ) ) ); reinterpret_cast<VkPipelineLayout *>( &m_pipelineLayout ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreatePipelineLayout" ); detail::throwResultException( result, "vkCreatePipelineLayout" );
} }
} }
@ -4976,11 +4957,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_pipelineLayout, rhs.m_pipelineLayout );
m_pipelineLayout = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -5062,7 +5042,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkPrivateDataSlot *>( &m_privateDataSlot ) ) ); reinterpret_cast<VkPrivateDataSlot *>( &m_privateDataSlot ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreatePrivateDataSlot" ); detail::throwResultException( result, "vkCreatePrivateDataSlot" );
} }
} }
@ -5100,11 +5080,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_privateDataSlot, rhs.m_privateDataSlot );
m_privateDataSlot = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -5186,7 +5165,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkQueryPool *>( &m_queryPool ) ) ); reinterpret_cast<VkQueryPool *>( &m_queryPool ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateQueryPool" ); detail::throwResultException( result, "vkCreateQueryPool" );
} }
} }
@ -5224,11 +5203,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_queryPool, rhs.m_queryPool );
m_queryPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queryPool, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -5361,8 +5339,8 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
m_queue = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queue, {} ); std::swap( m_queue, rhs.m_queue );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); std::swap( m_dispatcher, rhs.m_dispatcher );
} }
return *this; return *this;
} }
@ -5456,7 +5434,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkRenderPass *>( &m_renderPass ) ) ); reinterpret_cast<VkRenderPass *>( &m_renderPass ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateRenderPass" ); detail::throwResultException( result, "vkCreateRenderPass" );
} }
} }
@ -5474,7 +5452,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkRenderPass *>( &m_renderPass ) ) ); reinterpret_cast<VkRenderPass *>( &m_renderPass ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateRenderPass2" ); detail::throwResultException( result, "vkCreateRenderPass2" );
} }
} }
@ -5512,11 +5490,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_renderPass, rhs.m_renderPass );
m_renderPass = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_renderPass, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -5601,7 +5578,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkSampler *>( &m_sampler ) ) ); reinterpret_cast<VkSampler *>( &m_sampler ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateSampler" ); detail::throwResultException( result, "vkCreateSampler" );
} }
} }
@ -5639,11 +5616,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_sampler, rhs.m_sampler );
m_sampler = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_sampler, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -5724,7 +5700,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkSamplerYcbcrConversion *>( &m_ycbcrConversion ) ) ); reinterpret_cast<VkSamplerYcbcrConversion *>( &m_ycbcrConversion ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateSamplerYcbcrConversion" ); detail::throwResultException( result, "vkCreateSamplerYcbcrConversion" );
} }
} }
@ -5762,11 +5738,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_ycbcrConversion, rhs.m_ycbcrConversion );
m_ycbcrConversion = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -5848,7 +5823,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkSemaphore *>( &m_semaphore ) ) ); reinterpret_cast<VkSemaphore *>( &m_semaphore ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateSemaphore" ); detail::throwResultException( result, "vkCreateSemaphore" );
} }
} }
@ -5886,11 +5861,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_semaphore, rhs.m_semaphore );
m_semaphore = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphore, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -5976,7 +5950,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkSemaphoreSciSyncPoolNV *>( &m_semaphorePool ) ) ); reinterpret_cast<VkSemaphoreSciSyncPoolNV *>( &m_semaphorePool ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateSemaphoreSciSyncPoolNV" ); detail::throwResultException( result, "vkCreateSemaphoreSciSyncPoolNV" );
} }
} }
@ -6014,11 +5988,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_semaphorePool, rhs.m_semaphorePool );
m_semaphorePool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphorePool, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -6101,7 +6074,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkShaderModule *>( &m_shaderModule ) ) ); reinterpret_cast<VkShaderModule *>( &m_shaderModule ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateShaderModule" ); detail::throwResultException( result, "vkCreateShaderModule" );
} }
} }
@ -6139,11 +6112,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_shaderModule, rhs.m_shaderModule );
m_shaderModule = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shaderModule, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -6224,7 +6196,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateDisplayPlaneSurfaceKHR" ); detail::throwResultException( result, "vkCreateDisplayPlaneSurfaceKHR" );
} }
} }
@ -6242,7 +6214,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateHeadlessSurfaceEXT" ); detail::throwResultException( result, "vkCreateHeadlessSurfaceEXT" );
} }
} }
@ -6280,11 +6252,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_instance, rhs.m_instance );
m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ); std::swap( m_surface, rhs.m_surface );
m_surface = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surface, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -6365,7 +6336,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkSwapchainKHR *>( &m_swapchain ) ) ); reinterpret_cast<VkSwapchainKHR *>( &m_swapchain ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
throwResultException( result, "vkCreateSwapchainKHR" ); detail::throwResultException( result, "vkCreateSwapchainKHR" );
} }
} }
@ -6403,11 +6374,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
if ( this != &rhs ) if ( this != &rhs )
{ {
clear(); std::swap( m_device, rhs.m_device );
m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); std::swap( m_swapchain, rhs.m_swapchain );
m_swapchain = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchain, {} ); std::swap( m_allocator, rhs.m_allocator );
m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); std::swap( m_dispatcher, rhs.m_dispatcher );
m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
} }
return *this; return *this;
} }
@ -6506,7 +6476,7 @@ namespace VULKAN_HPP_NAMESPACE
} }
else else
{ {
throwResultException( result, "vkCreateSharedSwapchainsKHR" ); detail::throwResultException( result, "vkCreateSharedSwapchainsKHR" );
} }
} }