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

Updated generated vulkan/* files

Browse Source
This commit is contained in:
Nikolai Siukosev 2024-07-22 18:41:50 +04:00
parent f35e9c9f9b
commit 61852c758c
8 changed files with 1573 additions and 603 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
vulkan/vulkan.cppm
View File

@ -62,6 +62,8 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::UniqueHandle; using VULKAN_HPP_NAMESPACE::UniqueHandle;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
using VULKAN_HPP_NAMESPACE::exchange;
//================== //==================
//=== BASE TYPEs === //=== BASE TYPEs ===
//================== //==================
@ -4812,7 +4814,6 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_RAII_NAMESPACE::Context; using VULKAN_HPP_RAII_NAMESPACE::Context;
using VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher; using VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher;
using VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher; using VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher;
using VULKAN_HPP_RAII_NAMESPACE::exchange;
using VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher; using VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher;
//==================== //====================

13
vulkan/vulkan.hpp
View File

@ -12,6 +12,7 @@
#include <array> // ArrayWrapperND #include <array> // ArrayWrapperND
#include <string.h> // strnlen #include <string.h> // strnlen
#include <string> // std::string #include <string> // std::string
#include <utility> // std::exchange
#include <vulkan/vulkan.h> #include <vulkan/vulkan.h>
#include <vulkan/vulkan_hpp_macros.hpp> #include <vulkan/vulkan_hpp_macros.hpp>
@ -5889,6 +5890,18 @@ namespace VULKAN_HPP_NAMESPACE
} }
#endif #endif
#if ( 14 <= VULKAN_HPP_CPP_VERSION )
using std::exchange;
#else
template <class T, class U = T>
VULKAN_HPP_CONSTEXPR_14 VULKAN_HPP_INLINE T exchange( T & obj, U && newValue )
{
T oldValue = std::move( obj );
obj = std::forward<U>( newValue );
return oldValue;
}
#endif
#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) #if !defined( VULKAN_HPP_NO_SMART_HANDLE )
struct AllocationCallbacks; struct AllocationCallbacks;

591
vulkan/vulkan_handles.hpp
View File

@ -2437,8 +2437,19 @@ namespace VULKAN_HPP_NAMESPACE
SurfaceKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue SurfaceKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
SurfaceKHR( SurfaceKHR const & rhs ) = default; SurfaceKHR( SurfaceKHR const & rhs ) = default;
SurfaceKHR & operator=( SurfaceKHR const & rhs ) = default; SurfaceKHR & operator=( SurfaceKHR const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
SurfaceKHR( SurfaceKHR && rhs ) = default; SurfaceKHR( SurfaceKHR && rhs ) = default;
SurfaceKHR & operator=( SurfaceKHR && rhs ) = default; SurfaceKHR & operator=( SurfaceKHR && rhs ) = default;
#else
SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_surfaceKHR, {} ) ) {}
SurfaceKHR & operator=( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT
{
m_surfaceKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_surfaceKHR, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -2536,8 +2547,22 @@ namespace VULKAN_HPP_NAMESPACE
DebugReportCallbackEXT() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DebugReportCallbackEXT() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DebugReportCallbackEXT( DebugReportCallbackEXT const & rhs ) = default; DebugReportCallbackEXT( DebugReportCallbackEXT const & rhs ) = default;
DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & rhs ) = default; DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) = default; DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) = default;
DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) = default; DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) = default;
#else
DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT
: m_debugReportCallbackEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugReportCallbackEXT, {} ) )
{
}
DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT
{
m_debugReportCallbackEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugReportCallbackEXT, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -2638,8 +2663,22 @@ namespace VULKAN_HPP_NAMESPACE
DebugUtilsMessengerEXT() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DebugUtilsMessengerEXT() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & rhs ) = default; DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & rhs ) = default;
DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & rhs ) = default; DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) = default; DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) = default;
DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) = default; DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) = default;
#else
DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT
: m_debugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugUtilsMessengerEXT, {} ) )
{
}
DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT
{
m_debugUtilsMessengerEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugUtilsMessengerEXT, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -2734,8 +2773,19 @@ namespace VULKAN_HPP_NAMESPACE
DisplayKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DisplayKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DisplayKHR( DisplayKHR const & rhs ) = default; DisplayKHR( DisplayKHR const & rhs ) = default;
DisplayKHR & operator=( DisplayKHR const & rhs ) = default; DisplayKHR & operator=( DisplayKHR const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DisplayKHR( DisplayKHR && rhs ) = default; DisplayKHR( DisplayKHR && rhs ) = default;
DisplayKHR & operator=( DisplayKHR && rhs ) = default; DisplayKHR & operator=( DisplayKHR && rhs ) = default;
#else
DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_displayKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayKHR, {} ) ) {}
DisplayKHR & operator=( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT
{
m_displayKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayKHR, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -2833,8 +2883,19 @@ namespace VULKAN_HPP_NAMESPACE
SwapchainKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue SwapchainKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
SwapchainKHR( SwapchainKHR const & rhs ) = default; SwapchainKHR( SwapchainKHR const & rhs ) = default;
SwapchainKHR & operator=( SwapchainKHR const & rhs ) = default; SwapchainKHR & operator=( SwapchainKHR const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
SwapchainKHR( SwapchainKHR && rhs ) = default; SwapchainKHR( SwapchainKHR && rhs ) = default;
SwapchainKHR & operator=( SwapchainKHR && rhs ) = default; SwapchainKHR & operator=( SwapchainKHR && rhs ) = default;
#else
SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_swapchainKHR, {} ) ) {}
SwapchainKHR & operator=( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT
{
m_swapchainKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_swapchainKHR, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -2932,8 +2993,19 @@ namespace VULKAN_HPP_NAMESPACE
Semaphore() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Semaphore() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Semaphore( Semaphore const & rhs ) = default; Semaphore( Semaphore const & rhs ) = default;
Semaphore & operator=( Semaphore const & rhs ) = default; Semaphore & operator=( Semaphore const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Semaphore( Semaphore && rhs ) = default; Semaphore( Semaphore && rhs ) = default;
Semaphore & operator=( Semaphore && rhs ) = default; Semaphore & operator=( Semaphore && rhs ) = default;
#else
Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT : m_semaphore( VULKAN_HPP_NAMESPACE::exchange( rhs.m_semaphore, {} ) ) {}
Semaphore & operator=( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT
{
m_semaphore = VULKAN_HPP_NAMESPACE::exchange( rhs.m_semaphore, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3031,8 +3103,19 @@ namespace VULKAN_HPP_NAMESPACE
Fence() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Fence() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Fence( Fence const & rhs ) = default; Fence( Fence const & rhs ) = default;
Fence & operator=( Fence const & rhs ) = default; Fence & operator=( Fence const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Fence( Fence && rhs ) = default; Fence( Fence && rhs ) = default;
Fence & operator=( Fence && rhs ) = default; Fence & operator=( Fence && rhs ) = default;
#else
Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT : m_fence( VULKAN_HPP_NAMESPACE::exchange( rhs.m_fence, {} ) ) {}
Fence & operator=( Fence && rhs ) VULKAN_HPP_NOEXCEPT
{
m_fence = VULKAN_HPP_NAMESPACE::exchange( rhs.m_fence, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3130,8 +3213,22 @@ namespace VULKAN_HPP_NAMESPACE
PerformanceConfigurationINTEL() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue PerformanceConfigurationINTEL() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & rhs ) = default; PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & rhs ) = default;
PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & rhs ) = default; PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) = default; PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) = default;
PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) = default; PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) = default;
#else
PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT
: m_performanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::exchange( rhs.m_performanceConfigurationINTEL, {} ) )
{
}
PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT
{
m_performanceConfigurationINTEL = VULKAN_HPP_NAMESPACE::exchange( rhs.m_performanceConfigurationINTEL, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3226,8 +3323,19 @@ namespace VULKAN_HPP_NAMESPACE
QueryPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue QueryPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
QueryPool( QueryPool const & rhs ) = default; QueryPool( QueryPool const & rhs ) = default;
QueryPool & operator=( QueryPool const & rhs ) = default; QueryPool & operator=( QueryPool const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
QueryPool( QueryPool && rhs ) = default; QueryPool( QueryPool && rhs ) = default;
QueryPool & operator=( QueryPool && rhs ) = default; QueryPool & operator=( QueryPool && rhs ) = default;
#else
QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT : m_queryPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_queryPool, {} ) ) {}
QueryPool & operator=( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT
{
m_queryPool = VULKAN_HPP_NAMESPACE::exchange( rhs.m_queryPool, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3325,8 +3433,19 @@ namespace VULKAN_HPP_NAMESPACE
Buffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Buffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Buffer( Buffer const & rhs ) = default; Buffer( Buffer const & rhs ) = default;
Buffer & operator=( Buffer const & rhs ) = default; Buffer & operator=( Buffer const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Buffer( Buffer && rhs ) = default; Buffer( Buffer && rhs ) = default;
Buffer & operator=( Buffer && rhs ) = default; Buffer & operator=( Buffer && rhs ) = default;
#else
Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT : m_buffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_buffer, {} ) ) {}
Buffer & operator=( Buffer && rhs ) VULKAN_HPP_NOEXCEPT
{
m_buffer = VULKAN_HPP_NAMESPACE::exchange( rhs.m_buffer, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3424,8 +3543,19 @@ namespace VULKAN_HPP_NAMESPACE
PipelineLayout() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue PipelineLayout() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
PipelineLayout( PipelineLayout const & rhs ) = default; PipelineLayout( PipelineLayout const & rhs ) = default;
PipelineLayout & operator=( PipelineLayout const & rhs ) = default; PipelineLayout & operator=( PipelineLayout const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
PipelineLayout( PipelineLayout && rhs ) = default; PipelineLayout( PipelineLayout && rhs ) = default;
PipelineLayout & operator=( PipelineLayout && rhs ) = default; PipelineLayout & operator=( PipelineLayout && rhs ) = default;
#else
PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ) ) {}
PipelineLayout & operator=( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT
{
m_pipelineLayout = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineLayout, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3523,8 +3653,19 @@ namespace VULKAN_HPP_NAMESPACE
DescriptorSet() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DescriptorSet() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DescriptorSet( DescriptorSet const & rhs ) = default; DescriptorSet( DescriptorSet const & rhs ) = default;
DescriptorSet & operator=( DescriptorSet const & rhs ) = default; DescriptorSet & operator=( DescriptorSet const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DescriptorSet( DescriptorSet && rhs ) = default; DescriptorSet( DescriptorSet && rhs ) = default;
DescriptorSet & operator=( DescriptorSet && rhs ) = default; DescriptorSet & operator=( DescriptorSet && rhs ) = default;
#else
DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSet, {} ) ) {}
DescriptorSet & operator=( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT
{
m_descriptorSet = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSet, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3622,8 +3763,19 @@ namespace VULKAN_HPP_NAMESPACE
ImageView() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue ImageView() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
ImageView( ImageView const & rhs ) = default; ImageView( ImageView const & rhs ) = default;
ImageView & operator=( ImageView const & rhs ) = default; ImageView & operator=( ImageView const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
ImageView( ImageView && rhs ) = default; ImageView( ImageView && rhs ) = default;
ImageView & operator=( ImageView && rhs ) = default; ImageView & operator=( ImageView && rhs ) = default;
#else
ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT : m_imageView( VULKAN_HPP_NAMESPACE::exchange( rhs.m_imageView, {} ) ) {}
ImageView & operator=( ImageView && rhs ) VULKAN_HPP_NOEXCEPT
{
m_imageView = VULKAN_HPP_NAMESPACE::exchange( rhs.m_imageView, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3721,8 +3873,19 @@ namespace VULKAN_HPP_NAMESPACE
Pipeline() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Pipeline() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Pipeline( Pipeline const & rhs ) = default; Pipeline( Pipeline const & rhs ) = default;
Pipeline & operator=( Pipeline const & rhs ) = default; Pipeline & operator=( Pipeline const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Pipeline( Pipeline && rhs ) = default; Pipeline( Pipeline && rhs ) = default;
Pipeline & operator=( Pipeline && rhs ) = default; Pipeline & operator=( Pipeline && rhs ) = default;
#else
Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT : m_pipeline( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipeline, {} ) ) {}
Pipeline & operator=( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT
{
m_pipeline = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipeline, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3820,8 +3983,19 @@ namespace VULKAN_HPP_NAMESPACE
ShaderEXT() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue ShaderEXT() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
ShaderEXT( ShaderEXT const & rhs ) = default; ShaderEXT( ShaderEXT const & rhs ) = default;
ShaderEXT & operator=( ShaderEXT const & rhs ) = default; ShaderEXT & operator=( ShaderEXT const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
ShaderEXT( ShaderEXT && rhs ) = default; ShaderEXT( ShaderEXT && rhs ) = default;
ShaderEXT & operator=( ShaderEXT && rhs ) = default; ShaderEXT & operator=( ShaderEXT && rhs ) = default;
#else
ShaderEXT( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderEXT, {} ) ) {}
ShaderEXT & operator=( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT
{
m_shaderEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderEXT, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR ShaderEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR ShaderEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3913,8 +4087,19 @@ namespace VULKAN_HPP_NAMESPACE
Image() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Image() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Image( Image const & rhs ) = default; Image( Image const & rhs ) = default;
Image & operator=( Image const & rhs ) = default; Image & operator=( Image const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Image( Image && rhs ) = default; Image( Image && rhs ) = default;
Image & operator=( Image && rhs ) = default; Image & operator=( Image && rhs ) = default;
#else
Image( Image && rhs ) VULKAN_HPP_NOEXCEPT : m_image( VULKAN_HPP_NAMESPACE::exchange( rhs.m_image, {} ) ) {}
Image & operator=( Image && rhs ) VULKAN_HPP_NOEXCEPT
{
m_image = VULKAN_HPP_NAMESPACE::exchange( rhs.m_image, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4012,8 +4197,22 @@ namespace VULKAN_HPP_NAMESPACE
AccelerationStructureNV() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue AccelerationStructureNV() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
AccelerationStructureNV( AccelerationStructureNV const & rhs ) = default; AccelerationStructureNV( AccelerationStructureNV const & rhs ) = default;
AccelerationStructureNV & operator=( AccelerationStructureNV const & rhs ) = default; AccelerationStructureNV & operator=( AccelerationStructureNV const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
AccelerationStructureNV( AccelerationStructureNV && rhs ) = default; AccelerationStructureNV( AccelerationStructureNV && rhs ) = default;
AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) = default; AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) = default;
#else
AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT
: m_accelerationStructureNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructureNV, {} ) )
{
}
AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT
{
m_accelerationStructureNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructureNV, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4114,8 +4313,22 @@ namespace VULKAN_HPP_NAMESPACE
OpticalFlowSessionNV() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue OpticalFlowSessionNV() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
OpticalFlowSessionNV( OpticalFlowSessionNV const & rhs ) = default; OpticalFlowSessionNV( OpticalFlowSessionNV const & rhs ) = default;
OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & rhs ) = default; OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) = default; OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) = default;
OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) = default; OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) = default;
#else
OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT
: m_opticalFlowSessionNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_opticalFlowSessionNV, {} ) )
{
}
OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT
{
m_opticalFlowSessionNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_opticalFlowSessionNV, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4210,8 +4423,22 @@ namespace VULKAN_HPP_NAMESPACE
DescriptorUpdateTemplate() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DescriptorUpdateTemplate() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DescriptorUpdateTemplate( DescriptorUpdateTemplate const & rhs ) = default; DescriptorUpdateTemplate( DescriptorUpdateTemplate const & rhs ) = default;
DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & rhs ) = default; DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) = default; DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) = default;
DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) = default; DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) = default;
#else
DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT
: m_descriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} ) )
{
}
DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT
{
m_descriptorUpdateTemplate = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4314,8 +4541,19 @@ namespace VULKAN_HPP_NAMESPACE
Event() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Event() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Event( Event const & rhs ) = default; Event( Event const & rhs ) = default;
Event & operator=( Event const & rhs ) = default; Event & operator=( Event const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Event( Event && rhs ) = default; Event( Event && rhs ) = default;
Event & operator=( Event && rhs ) = default; Event & operator=( Event && rhs ) = default;
#else
Event( Event && rhs ) VULKAN_HPP_NOEXCEPT : m_event( VULKAN_HPP_NAMESPACE::exchange( rhs.m_event, {} ) ) {}
Event & operator=( Event && rhs ) VULKAN_HPP_NOEXCEPT
{
m_event = VULKAN_HPP_NAMESPACE::exchange( rhs.m_event, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4413,8 +4651,22 @@ namespace VULKAN_HPP_NAMESPACE
AccelerationStructureKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue AccelerationStructureKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
AccelerationStructureKHR( AccelerationStructureKHR const & rhs ) = default; AccelerationStructureKHR( AccelerationStructureKHR const & rhs ) = default;
AccelerationStructureKHR & operator=( AccelerationStructureKHR const & rhs ) = default; AccelerationStructureKHR & operator=( AccelerationStructureKHR const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
AccelerationStructureKHR( AccelerationStructureKHR && rhs ) = default; AccelerationStructureKHR( AccelerationStructureKHR && rhs ) = default;
AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) = default; AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) = default;
#else
AccelerationStructureKHR( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT
: m_accelerationStructureKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructureKHR, {} ) )
{
}
AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT
{
m_accelerationStructureKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructureKHR, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4515,8 +4767,19 @@ namespace VULKAN_HPP_NAMESPACE
MicromapEXT() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue MicromapEXT() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
MicromapEXT( MicromapEXT const & rhs ) = default; MicromapEXT( MicromapEXT const & rhs ) = default;
MicromapEXT & operator=( MicromapEXT const & rhs ) = default; MicromapEXT & operator=( MicromapEXT const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
MicromapEXT( MicromapEXT && rhs ) = default; MicromapEXT( MicromapEXT && rhs ) = default;
MicromapEXT & operator=( MicromapEXT && rhs ) = default; MicromapEXT & operator=( MicromapEXT && rhs ) = default;
#else
MicromapEXT( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_micromapEXT, {} ) ) {}
MicromapEXT & operator=( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT
{
m_micromapEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_micromapEXT, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4608,8 +4871,19 @@ namespace VULKAN_HPP_NAMESPACE
CommandBuffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue CommandBuffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
CommandBuffer( CommandBuffer const & rhs ) = default; CommandBuffer( CommandBuffer const & rhs ) = default;
CommandBuffer & operator=( CommandBuffer const & rhs ) = default; CommandBuffer & operator=( CommandBuffer const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
CommandBuffer( CommandBuffer && rhs ) = default; CommandBuffer( CommandBuffer && rhs ) = default;
CommandBuffer & operator=( CommandBuffer && rhs ) = default; CommandBuffer & operator=( CommandBuffer && rhs ) = default;
#else
CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandBuffer, {} ) ) {}
CommandBuffer & operator=( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT
{
m_commandBuffer = VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandBuffer, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -7008,8 +7282,19 @@ namespace VULKAN_HPP_NAMESPACE
DeviceMemory() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DeviceMemory() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DeviceMemory( DeviceMemory const & rhs ) = default; DeviceMemory( DeviceMemory const & rhs ) = default;
DeviceMemory & operator=( DeviceMemory const & rhs ) = default; DeviceMemory & operator=( DeviceMemory const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DeviceMemory( DeviceMemory && rhs ) = default; DeviceMemory( DeviceMemory && rhs ) = default;
DeviceMemory & operator=( DeviceMemory && rhs ) = default; DeviceMemory & operator=( DeviceMemory && rhs ) = default;
#else
DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( VULKAN_HPP_NAMESPACE::exchange( rhs.m_deviceMemory, {} ) ) {}
DeviceMemory & operator=( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT
{
m_deviceMemory = VULKAN_HPP_NAMESPACE::exchange( rhs.m_deviceMemory, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -7107,8 +7392,19 @@ namespace VULKAN_HPP_NAMESPACE
VideoSessionKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue VideoSessionKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
VideoSessionKHR( VideoSessionKHR const & rhs ) = default; VideoSessionKHR( VideoSessionKHR const & rhs ) = default;
VideoSessionKHR & operator=( VideoSessionKHR const & rhs ) = default; VideoSessionKHR & operator=( VideoSessionKHR const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
VideoSessionKHR( VideoSessionKHR && rhs ) = default; VideoSessionKHR( VideoSessionKHR && rhs ) = default;
VideoSessionKHR & operator=( VideoSessionKHR && rhs ) = default; VideoSessionKHR & operator=( VideoSessionKHR && rhs ) = default;
#else
VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionKHR, {} ) ) {}
VideoSessionKHR & operator=( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT
{
m_videoSessionKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionKHR, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -7200,8 +7496,22 @@ namespace VULKAN_HPP_NAMESPACE
DeferredOperationKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DeferredOperationKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DeferredOperationKHR( DeferredOperationKHR const & rhs ) = default; DeferredOperationKHR( DeferredOperationKHR const & rhs ) = default;
DeferredOperationKHR & operator=( DeferredOperationKHR const & rhs ) = default; DeferredOperationKHR & operator=( DeferredOperationKHR const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DeferredOperationKHR( DeferredOperationKHR && rhs ) = default; DeferredOperationKHR( DeferredOperationKHR && rhs ) = default;
DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) = default; DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) = default;
#else
DeferredOperationKHR( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT
: m_deferredOperationKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_deferredOperationKHR, {} ) )
{
}
DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT
{
m_deferredOperationKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_deferredOperationKHR, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -7297,8 +7607,22 @@ namespace VULKAN_HPP_NAMESPACE
BufferCollectionFUCHSIA() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue BufferCollectionFUCHSIA() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & rhs ) = default; BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & rhs ) = default;
BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & rhs ) = default; BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & rhs ) = default;
# if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) = default; BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) = default;
BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) = default; BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) = default;
# else
BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT
: m_bufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferCollectionFUCHSIA, {} ) )
{
}
BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT
{
m_bufferCollectionFUCHSIA = VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferCollectionFUCHSIA, {} );
return *this;
}
# endif
VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -7400,8 +7724,19 @@ namespace VULKAN_HPP_NAMESPACE
BufferView() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue BufferView() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
BufferView( BufferView const & rhs ) = default; BufferView( BufferView const & rhs ) = default;
BufferView & operator=( BufferView const & rhs ) = default; BufferView & operator=( BufferView const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
BufferView( BufferView && rhs ) = default; BufferView( BufferView && rhs ) = default;
BufferView & operator=( BufferView && rhs ) = default; BufferView & operator=( BufferView && rhs ) = default;
#else
BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT : m_bufferView( VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferView, {} ) ) {}
BufferView & operator=( BufferView && rhs ) VULKAN_HPP_NOEXCEPT
{
m_bufferView = VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferView, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -7499,8 +7834,19 @@ namespace VULKAN_HPP_NAMESPACE
CommandPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue CommandPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
CommandPool( CommandPool const & rhs ) = default; CommandPool( CommandPool const & rhs ) = default;
CommandPool & operator=( CommandPool const & rhs ) = default; CommandPool & operator=( CommandPool const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
CommandPool( CommandPool && rhs ) = default; CommandPool( CommandPool && rhs ) = default;
CommandPool & operator=( CommandPool && rhs ) = default; CommandPool & operator=( CommandPool && rhs ) = default;
#else
CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT : m_commandPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandPool, {} ) ) {}
CommandPool & operator=( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT
{
m_commandPool = VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandPool, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -7598,8 +7944,19 @@ namespace VULKAN_HPP_NAMESPACE
PipelineCache() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue PipelineCache() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
PipelineCache( PipelineCache const & rhs ) = default; PipelineCache( PipelineCache const & rhs ) = default;
PipelineCache & operator=( PipelineCache const & rhs ) = default; PipelineCache & operator=( PipelineCache const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
PipelineCache( PipelineCache && rhs ) = default; PipelineCache( PipelineCache && rhs ) = default;
PipelineCache & operator=( PipelineCache && rhs ) = default; PipelineCache & operator=( PipelineCache && rhs ) = default;
#else
PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineCache, {} ) ) {}
PipelineCache & operator=( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT
{
m_pipelineCache = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineCache, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -7697,8 +8054,19 @@ namespace VULKAN_HPP_NAMESPACE
CuFunctionNVX() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue CuFunctionNVX() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
CuFunctionNVX( CuFunctionNVX const & rhs ) = default; CuFunctionNVX( CuFunctionNVX const & rhs ) = default;
CuFunctionNVX & operator=( CuFunctionNVX const & rhs ) = default; CuFunctionNVX & operator=( CuFunctionNVX const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
CuFunctionNVX( CuFunctionNVX && rhs ) = default; CuFunctionNVX( CuFunctionNVX && rhs ) = default;
CuFunctionNVX & operator=( CuFunctionNVX && rhs ) = default; CuFunctionNVX & operator=( CuFunctionNVX && rhs ) = default;
#else
CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cuFunctionNVX, {} ) ) {}
CuFunctionNVX & operator=( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT
{
m_cuFunctionNVX = VULKAN_HPP_NAMESPACE::exchange( rhs.m_cuFunctionNVX, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -7796,8 +8164,19 @@ namespace VULKAN_HPP_NAMESPACE
CuModuleNVX() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue CuModuleNVX() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
CuModuleNVX( CuModuleNVX const & rhs ) = default; CuModuleNVX( CuModuleNVX const & rhs ) = default;
CuModuleNVX & operator=( CuModuleNVX const & rhs ) = default; CuModuleNVX & operator=( CuModuleNVX const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
CuModuleNVX( CuModuleNVX && rhs ) = default; CuModuleNVX( CuModuleNVX && rhs ) = default;
CuModuleNVX & operator=( CuModuleNVX && rhs ) = default; CuModuleNVX & operator=( CuModuleNVX && rhs ) = default;
#else
CuModuleNVX( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cuModuleNVX, {} ) ) {}
CuModuleNVX & operator=( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT
{
m_cuModuleNVX = VULKAN_HPP_NAMESPACE::exchange( rhs.m_cuModuleNVX, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -7896,8 +8275,19 @@ namespace VULKAN_HPP_NAMESPACE
CudaFunctionNV() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue CudaFunctionNV() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
CudaFunctionNV( CudaFunctionNV const & rhs ) = default; CudaFunctionNV( CudaFunctionNV const & rhs ) = default;
CudaFunctionNV & operator=( CudaFunctionNV const & rhs ) = default; CudaFunctionNV & operator=( CudaFunctionNV const & rhs ) = default;
# if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
CudaFunctionNV( CudaFunctionNV && rhs ) = default; CudaFunctionNV( CudaFunctionNV && rhs ) = default;
CudaFunctionNV & operator=( CudaFunctionNV && rhs ) = default; CudaFunctionNV & operator=( CudaFunctionNV && rhs ) = default;
# else
CudaFunctionNV( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cudaFunctionNV, {} ) ) {}
CudaFunctionNV & operator=( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT
{
m_cudaFunctionNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_cudaFunctionNV, {} );
return *this;
}
# endif
VULKAN_HPP_CONSTEXPR CudaFunctionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR CudaFunctionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -7997,8 +8387,19 @@ namespace VULKAN_HPP_NAMESPACE
CudaModuleNV() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue CudaModuleNV() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
CudaModuleNV( CudaModuleNV const & rhs ) = default; CudaModuleNV( CudaModuleNV const & rhs ) = default;
CudaModuleNV & operator=( CudaModuleNV const & rhs ) = default; CudaModuleNV & operator=( CudaModuleNV const & rhs ) = default;
# if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
CudaModuleNV( CudaModuleNV && rhs ) = default; CudaModuleNV( CudaModuleNV && rhs ) = default;
CudaModuleNV & operator=( CudaModuleNV && rhs ) = default; CudaModuleNV & operator=( CudaModuleNV && rhs ) = default;
# else
CudaModuleNV( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cudaModuleNV, {} ) ) {}
CudaModuleNV & operator=( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT
{
m_cudaModuleNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_cudaModuleNV, {} );
return *this;
}
# endif
VULKAN_HPP_CONSTEXPR CudaModuleNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR CudaModuleNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -8097,8 +8498,19 @@ namespace VULKAN_HPP_NAMESPACE
DescriptorPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DescriptorPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DescriptorPool( DescriptorPool const & rhs ) = default; DescriptorPool( DescriptorPool const & rhs ) = default;
DescriptorPool & operator=( DescriptorPool const & rhs ) = default; DescriptorPool & operator=( DescriptorPool const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DescriptorPool( DescriptorPool && rhs ) = default; DescriptorPool( DescriptorPool && rhs ) = default;
DescriptorPool & operator=( DescriptorPool && rhs ) = default; DescriptorPool & operator=( DescriptorPool && rhs ) = default;
#else
DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) ) {}
DescriptorPool & operator=( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT
{
m_descriptorPool = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorPool, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -8196,8 +8608,22 @@ namespace VULKAN_HPP_NAMESPACE
DescriptorSetLayout() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DescriptorSetLayout() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DescriptorSetLayout( DescriptorSetLayout const & rhs ) = default; DescriptorSetLayout( DescriptorSetLayout const & rhs ) = default;
DescriptorSetLayout & operator=( DescriptorSetLayout const & rhs ) = default; DescriptorSetLayout & operator=( DescriptorSetLayout const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DescriptorSetLayout( DescriptorSetLayout && rhs ) = default; DescriptorSetLayout( DescriptorSetLayout && rhs ) = default;
DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) = default; DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) = default;
#else
DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT
: m_descriptorSetLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} ) )
{
}
DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT
{
m_descriptorSetLayout = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -8298,8 +8724,19 @@ namespace VULKAN_HPP_NAMESPACE
Framebuffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Framebuffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Framebuffer( Framebuffer const & rhs ) = default; Framebuffer( Framebuffer const & rhs ) = default;
Framebuffer & operator=( Framebuffer const & rhs ) = default; Framebuffer & operator=( Framebuffer const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Framebuffer( Framebuffer && rhs ) = default; Framebuffer( Framebuffer && rhs ) = default;
Framebuffer & operator=( Framebuffer && rhs ) = default; Framebuffer & operator=( Framebuffer && rhs ) = default;
#else
Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT : m_framebuffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_framebuffer, {} ) ) {}
Framebuffer & operator=( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT
{
m_framebuffer = VULKAN_HPP_NAMESPACE::exchange( rhs.m_framebuffer, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -8397,8 +8834,22 @@ namespace VULKAN_HPP_NAMESPACE
IndirectCommandsLayoutNV() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue IndirectCommandsLayoutNV() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & rhs ) = default; IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & rhs ) = default;
IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & rhs ) = default; IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) = default; IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) = default;
IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) = default; IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) = default;
#else
IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT
: m_indirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectCommandsLayoutNV, {} ) )
{
}
IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT
{
m_indirectCommandsLayoutNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectCommandsLayoutNV, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -8493,8 +8944,19 @@ namespace VULKAN_HPP_NAMESPACE
PrivateDataSlot() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue PrivateDataSlot() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
PrivateDataSlot( PrivateDataSlot const & rhs ) = default; PrivateDataSlot( PrivateDataSlot const & rhs ) = default;
PrivateDataSlot & operator=( PrivateDataSlot const & rhs ) = default; PrivateDataSlot & operator=( PrivateDataSlot const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
PrivateDataSlot( PrivateDataSlot && rhs ) = default; PrivateDataSlot( PrivateDataSlot && rhs ) = default;
PrivateDataSlot & operator=( PrivateDataSlot && rhs ) = default; PrivateDataSlot & operator=( PrivateDataSlot && rhs ) = default;
#else
PrivateDataSlot( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( VULKAN_HPP_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ) ) {}
PrivateDataSlot & operator=( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT
{
m_privateDataSlot = VULKAN_HPP_NAMESPACE::exchange( rhs.m_privateDataSlot, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -8588,8 +9050,19 @@ namespace VULKAN_HPP_NAMESPACE
RenderPass() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue RenderPass() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
RenderPass( RenderPass const & rhs ) = default; RenderPass( RenderPass const & rhs ) = default;
RenderPass & operator=( RenderPass const & rhs ) = default; RenderPass & operator=( RenderPass const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
RenderPass( RenderPass && rhs ) = default; RenderPass( RenderPass && rhs ) = default;
RenderPass & operator=( RenderPass && rhs ) = default; RenderPass & operator=( RenderPass && rhs ) = default;
#else
RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT : m_renderPass( VULKAN_HPP_NAMESPACE::exchange( rhs.m_renderPass, {} ) ) {}
RenderPass & operator=( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT
{
m_renderPass = VULKAN_HPP_NAMESPACE::exchange( rhs.m_renderPass, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -8687,8 +9160,19 @@ namespace VULKAN_HPP_NAMESPACE
Sampler() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Sampler() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Sampler( Sampler const & rhs ) = default; Sampler( Sampler const & rhs ) = default;
Sampler & operator=( Sampler const & rhs ) = default; Sampler & operator=( Sampler const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Sampler( Sampler && rhs ) = default; Sampler( Sampler && rhs ) = default;
Sampler & operator=( Sampler && rhs ) = default; Sampler & operator=( Sampler && rhs ) = default;
#else
Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT : m_sampler( VULKAN_HPP_NAMESPACE::exchange( rhs.m_sampler, {} ) ) {}
Sampler & operator=( Sampler && rhs ) VULKAN_HPP_NOEXCEPT
{
m_sampler = VULKAN_HPP_NAMESPACE::exchange( rhs.m_sampler, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -8786,8 +9270,22 @@ namespace VULKAN_HPP_NAMESPACE
SamplerYcbcrConversion() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue SamplerYcbcrConversion() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
SamplerYcbcrConversion( SamplerYcbcrConversion const & rhs ) = default; SamplerYcbcrConversion( SamplerYcbcrConversion const & rhs ) = default;
SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & rhs ) = default; SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) = default; SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) = default;
SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) = default; SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) = default;
#else
SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT
: m_samplerYcbcrConversion( VULKAN_HPP_NAMESPACE::exchange( rhs.m_samplerYcbcrConversion, {} ) )
{
}
SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT
{
m_samplerYcbcrConversion = VULKAN_HPP_NAMESPACE::exchange( rhs.m_samplerYcbcrConversion, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -8890,8 +9388,19 @@ namespace VULKAN_HPP_NAMESPACE
ShaderModule() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue ShaderModule() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
ShaderModule( ShaderModule const & rhs ) = default; ShaderModule( ShaderModule const & rhs ) = default;
ShaderModule & operator=( ShaderModule const & rhs ) = default; ShaderModule & operator=( ShaderModule const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
ShaderModule( ShaderModule && rhs ) = default; ShaderModule( ShaderModule && rhs ) = default;
ShaderModule & operator=( ShaderModule && rhs ) = default; ShaderModule & operator=( ShaderModule && rhs ) = default;
#else
ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT : m_shaderModule( VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderModule, {} ) ) {}
ShaderModule & operator=( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT
{
m_shaderModule = VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderModule, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -8989,8 +9498,21 @@ namespace VULKAN_HPP_NAMESPACE
ValidationCacheEXT() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue ValidationCacheEXT() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
ValidationCacheEXT( ValidationCacheEXT const & rhs ) = default; ValidationCacheEXT( ValidationCacheEXT const & rhs ) = default;
ValidationCacheEXT & operator=( ValidationCacheEXT const & rhs ) = default; ValidationCacheEXT & operator=( ValidationCacheEXT const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
ValidationCacheEXT( ValidationCacheEXT && rhs ) = default; ValidationCacheEXT( ValidationCacheEXT && rhs ) = default;
ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) = default; ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) = default;
#else
ValidationCacheEXT( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_validationCacheEXT, {} ) )
{
}
ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT
{
m_validationCacheEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_validationCacheEXT, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -9090,8 +9612,22 @@ namespace VULKAN_HPP_NAMESPACE
VideoSessionParametersKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue VideoSessionParametersKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
VideoSessionParametersKHR( VideoSessionParametersKHR const & rhs ) = default; VideoSessionParametersKHR( VideoSessionParametersKHR const & rhs ) = default;
VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & rhs ) = default; VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) = default; VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) = default;
VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) = default; VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) = default;
#else
VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
: m_videoSessionParametersKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionParametersKHR, {} ) )
{
}
VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
{
m_videoSessionParametersKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionParametersKHR, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -9186,8 +9722,19 @@ namespace VULKAN_HPP_NAMESPACE
Queue() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Queue() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Queue( Queue const & rhs ) = default; Queue( Queue const & rhs ) = default;
Queue & operator=( Queue const & rhs ) = default; Queue & operator=( Queue const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Queue( Queue && rhs ) = default; Queue( Queue && rhs ) = default;
Queue & operator=( Queue && rhs ) = default; Queue & operator=( Queue && rhs ) = default;
#else
Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT : m_queue( VULKAN_HPP_NAMESPACE::exchange( rhs.m_queue, {} ) ) {}
Queue & operator=( Queue && rhs ) VULKAN_HPP_NOEXCEPT
{
m_queue = VULKAN_HPP_NAMESPACE::exchange( rhs.m_queue, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -9443,8 +9990,19 @@ namespace VULKAN_HPP_NAMESPACE
Device() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Device() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Device( Device const & rhs ) = default; Device( Device const & rhs ) = default;
Device & operator=( Device const & rhs ) = default; Device & operator=( Device const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Device( Device && rhs ) = default; Device( Device && rhs ) = default;
Device & operator=( Device && rhs ) = default; Device & operator=( Device && rhs ) = default;
#else
Device( Device && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) {}
Device & operator=( Device && rhs ) VULKAN_HPP_NOEXCEPT
{
m_device = VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -14613,8 +15171,19 @@ namespace VULKAN_HPP_NAMESPACE
DisplayModeKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DisplayModeKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DisplayModeKHR( DisplayModeKHR const & rhs ) = default; DisplayModeKHR( DisplayModeKHR const & rhs ) = default;
DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) = default; DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DisplayModeKHR( DisplayModeKHR && rhs ) = default; DisplayModeKHR( DisplayModeKHR && rhs ) = default;
DisplayModeKHR & operator=( DisplayModeKHR && rhs ) = default; DisplayModeKHR & operator=( DisplayModeKHR && rhs ) = default;
#else
DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ) ) {}
DisplayModeKHR & operator=( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT
{
m_displayModeKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayModeKHR, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -14712,8 +15281,19 @@ namespace VULKAN_HPP_NAMESPACE
PhysicalDevice() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue PhysicalDevice() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
PhysicalDevice( PhysicalDevice const & rhs ) = default; PhysicalDevice( PhysicalDevice const & rhs ) = default;
PhysicalDevice & operator=( PhysicalDevice const & rhs ) = default; PhysicalDevice & operator=( PhysicalDevice const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
PhysicalDevice( PhysicalDevice && rhs ) = default; PhysicalDevice( PhysicalDevice && rhs ) = default;
PhysicalDevice & operator=( PhysicalDevice && rhs ) = default; PhysicalDevice & operator=( PhysicalDevice && rhs ) = default;
#else
PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) {}
PhysicalDevice & operator=( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT
{
m_physicalDevice = VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -16146,8 +16726,19 @@ namespace VULKAN_HPP_NAMESPACE
Instance() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Instance() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Instance( Instance const & rhs ) = default; Instance( Instance const & rhs ) = default;
Instance & operator=( Instance const & rhs ) = default; Instance & operator=( Instance const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Instance( Instance && rhs ) = default; Instance( Instance && rhs ) = default;
Instance & operator=( Instance && rhs ) = default; Instance & operator=( Instance && rhs ) = default;
#else
Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT : m_instance( VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} ) ) {}
Instance & operator=( Instance && rhs ) VULKAN_HPP_NOEXCEPT
{
m_instance = VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

496
vulkan/vulkan_raii.hpp
View File

File diff suppressed because it is too large Load Diff

3
vulkan/vulkansc.cppm
View File

@ -62,6 +62,8 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::UniqueHandle; using VULKAN_HPP_NAMESPACE::UniqueHandle;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
using VULKAN_HPP_NAMESPACE::exchange;
//================== //==================
//=== BASE TYPEs === //=== BASE TYPEs ===
//================== //==================
@ -1835,7 +1837,6 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_RAII_NAMESPACE::Context; using VULKAN_HPP_RAII_NAMESPACE::Context;
using VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher; using VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher;
using VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher; using VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher;
using VULKAN_HPP_RAII_NAMESPACE::exchange;
using VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher; using VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher;
//==================== //====================

13
vulkan/vulkansc.hpp
View File

@ -12,6 +12,7 @@
#include <array> // ArrayWrapperND #include <array> // ArrayWrapperND
#include <string.h> // strnlen #include <string.h> // strnlen
#include <string> // std::string #include <string> // std::string
#include <utility> // std::exchange
#include <vulkan/vulkan_hpp_macros.hpp> #include <vulkan/vulkan_hpp_macros.hpp>
#include <vulkan/vulkan_sc_core.h> #include <vulkan/vulkan_sc_core.h>
@ -3151,6 +3152,18 @@ namespace VULKAN_HPP_NAMESPACE
} }
#endif #endif
#if ( 14 <= VULKAN_HPP_CPP_VERSION )
using std::exchange;
#else
template <class T, class U = T>
VULKAN_HPP_CONSTEXPR_14 VULKAN_HPP_INLINE T exchange( T & obj, U && newValue )
{
T oldValue = std::move( obj );
obj = std::forward<U>( newValue );
return oldValue;
}
#endif
#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) #if !defined( VULKAN_HPP_NO_SMART_HANDLE )
struct AllocationCallbacks; struct AllocationCallbacks;

375
vulkan/vulkansc_handles.hpp
View File

@ -1052,8 +1052,22 @@ namespace VULKAN_HPP_NAMESPACE
DebugUtilsMessengerEXT() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DebugUtilsMessengerEXT() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & rhs ) = default; DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & rhs ) = default;
DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & rhs ) = default; DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) = default; DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) = default;
DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) = default; DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) = default;
#else
DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT
: m_debugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugUtilsMessengerEXT, {} ) )
{
}
DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT
{
m_debugUtilsMessengerEXT = VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugUtilsMessengerEXT, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -1148,8 +1162,19 @@ namespace VULKAN_HPP_NAMESPACE
SurfaceKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue SurfaceKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
SurfaceKHR( SurfaceKHR const & rhs ) = default; SurfaceKHR( SurfaceKHR const & rhs ) = default;
SurfaceKHR & operator=( SurfaceKHR const & rhs ) = default; SurfaceKHR & operator=( SurfaceKHR const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
SurfaceKHR( SurfaceKHR && rhs ) = default; SurfaceKHR( SurfaceKHR && rhs ) = default;
SurfaceKHR & operator=( SurfaceKHR && rhs ) = default; SurfaceKHR & operator=( SurfaceKHR && rhs ) = default;
#else
SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_surfaceKHR, {} ) ) {}
SurfaceKHR & operator=( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT
{
m_surfaceKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_surfaceKHR, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -1247,8 +1272,19 @@ namespace VULKAN_HPP_NAMESPACE
DisplayKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DisplayKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DisplayKHR( DisplayKHR const & rhs ) = default; DisplayKHR( DisplayKHR const & rhs ) = default;
DisplayKHR & operator=( DisplayKHR const & rhs ) = default; DisplayKHR & operator=( DisplayKHR const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DisplayKHR( DisplayKHR && rhs ) = default; DisplayKHR( DisplayKHR && rhs ) = default;
DisplayKHR & operator=( DisplayKHR && rhs ) = default; DisplayKHR & operator=( DisplayKHR && rhs ) = default;
#else
DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_displayKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayKHR, {} ) ) {}
DisplayKHR & operator=( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT
{
m_displayKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayKHR, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -1346,8 +1382,19 @@ namespace VULKAN_HPP_NAMESPACE
SwapchainKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue SwapchainKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
SwapchainKHR( SwapchainKHR const & rhs ) = default; SwapchainKHR( SwapchainKHR const & rhs ) = default;
SwapchainKHR & operator=( SwapchainKHR const & rhs ) = default; SwapchainKHR & operator=( SwapchainKHR const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
SwapchainKHR( SwapchainKHR && rhs ) = default; SwapchainKHR( SwapchainKHR && rhs ) = default;
SwapchainKHR & operator=( SwapchainKHR && rhs ) = default; SwapchainKHR & operator=( SwapchainKHR && rhs ) = default;
#else
SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_swapchainKHR, {} ) ) {}
SwapchainKHR & operator=( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT
{
m_swapchainKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_swapchainKHR, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -1445,8 +1492,19 @@ namespace VULKAN_HPP_NAMESPACE
Semaphore() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Semaphore() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Semaphore( Semaphore const & rhs ) = default; Semaphore( Semaphore const & rhs ) = default;
Semaphore & operator=( Semaphore const & rhs ) = default; Semaphore & operator=( Semaphore const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Semaphore( Semaphore && rhs ) = default; Semaphore( Semaphore && rhs ) = default;
Semaphore & operator=( Semaphore && rhs ) = default; Semaphore & operator=( Semaphore && rhs ) = default;
#else
Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT : m_semaphore( VULKAN_HPP_NAMESPACE::exchange( rhs.m_semaphore, {} ) ) {}
Semaphore & operator=( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT
{
m_semaphore = VULKAN_HPP_NAMESPACE::exchange( rhs.m_semaphore, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -1544,8 +1602,19 @@ namespace VULKAN_HPP_NAMESPACE
Fence() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Fence() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Fence( Fence const & rhs ) = default; Fence( Fence const & rhs ) = default;
Fence & operator=( Fence const & rhs ) = default; Fence & operator=( Fence const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Fence( Fence && rhs ) = default; Fence( Fence && rhs ) = default;
Fence & operator=( Fence && rhs ) = default; Fence & operator=( Fence && rhs ) = default;
#else
Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT : m_fence( VULKAN_HPP_NAMESPACE::exchange( rhs.m_fence, {} ) ) {}
Fence & operator=( Fence && rhs ) VULKAN_HPP_NOEXCEPT
{
m_fence = VULKAN_HPP_NAMESPACE::exchange( rhs.m_fence, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -1643,8 +1712,19 @@ namespace VULKAN_HPP_NAMESPACE
QueryPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue QueryPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
QueryPool( QueryPool const & rhs ) = default; QueryPool( QueryPool const & rhs ) = default;
QueryPool & operator=( QueryPool const & rhs ) = default; QueryPool & operator=( QueryPool const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
QueryPool( QueryPool && rhs ) = default; QueryPool( QueryPool && rhs ) = default;
QueryPool & operator=( QueryPool && rhs ) = default; QueryPool & operator=( QueryPool && rhs ) = default;
#else
QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT : m_queryPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_queryPool, {} ) ) {}
QueryPool & operator=( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT
{
m_queryPool = VULKAN_HPP_NAMESPACE::exchange( rhs.m_queryPool, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -1742,8 +1822,19 @@ namespace VULKAN_HPP_NAMESPACE
PipelineLayout() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue PipelineLayout() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
PipelineLayout( PipelineLayout const & rhs ) = default; PipelineLayout( PipelineLayout const & rhs ) = default;
PipelineLayout & operator=( PipelineLayout const & rhs ) = default; PipelineLayout & operator=( PipelineLayout const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
PipelineLayout( PipelineLayout && rhs ) = default; PipelineLayout( PipelineLayout && rhs ) = default;
PipelineLayout & operator=( PipelineLayout && rhs ) = default; PipelineLayout & operator=( PipelineLayout && rhs ) = default;
#else
PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ) ) {}
PipelineLayout & operator=( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT
{
m_pipelineLayout = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineLayout, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -1841,8 +1932,19 @@ namespace VULKAN_HPP_NAMESPACE
DescriptorSet() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DescriptorSet() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DescriptorSet( DescriptorSet const & rhs ) = default; DescriptorSet( DescriptorSet const & rhs ) = default;
DescriptorSet & operator=( DescriptorSet const & rhs ) = default; DescriptorSet & operator=( DescriptorSet const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DescriptorSet( DescriptorSet && rhs ) = default; DescriptorSet( DescriptorSet && rhs ) = default;
DescriptorSet & operator=( DescriptorSet && rhs ) = default; DescriptorSet & operator=( DescriptorSet && rhs ) = default;
#else
DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSet, {} ) ) {}
DescriptorSet & operator=( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT
{
m_descriptorSet = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSet, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -1940,8 +2042,19 @@ namespace VULKAN_HPP_NAMESPACE
Buffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Buffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Buffer( Buffer const & rhs ) = default; Buffer( Buffer const & rhs ) = default;
Buffer & operator=( Buffer const & rhs ) = default; Buffer & operator=( Buffer const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Buffer( Buffer && rhs ) = default; Buffer( Buffer && rhs ) = default;
Buffer & operator=( Buffer && rhs ) = default; Buffer & operator=( Buffer && rhs ) = default;
#else
Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT : m_buffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_buffer, {} ) ) {}
Buffer & operator=( Buffer && rhs ) VULKAN_HPP_NOEXCEPT
{
m_buffer = VULKAN_HPP_NAMESPACE::exchange( rhs.m_buffer, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -2039,8 +2152,19 @@ namespace VULKAN_HPP_NAMESPACE
Pipeline() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Pipeline() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Pipeline( Pipeline const & rhs ) = default; Pipeline( Pipeline const & rhs ) = default;
Pipeline & operator=( Pipeline const & rhs ) = default; Pipeline & operator=( Pipeline const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Pipeline( Pipeline && rhs ) = default; Pipeline( Pipeline && rhs ) = default;
Pipeline & operator=( Pipeline && rhs ) = default; Pipeline & operator=( Pipeline && rhs ) = default;
#else
Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT : m_pipeline( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipeline, {} ) ) {}
Pipeline & operator=( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT
{
m_pipeline = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipeline, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -2138,8 +2262,19 @@ namespace VULKAN_HPP_NAMESPACE
Image() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Image() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Image( Image const & rhs ) = default; Image( Image const & rhs ) = default;
Image & operator=( Image const & rhs ) = default; Image & operator=( Image const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Image( Image && rhs ) = default; Image( Image && rhs ) = default;
Image & operator=( Image && rhs ) = default; Image & operator=( Image && rhs ) = default;
#else
Image( Image && rhs ) VULKAN_HPP_NOEXCEPT : m_image( VULKAN_HPP_NAMESPACE::exchange( rhs.m_image, {} ) ) {}
Image & operator=( Image && rhs ) VULKAN_HPP_NOEXCEPT
{
m_image = VULKAN_HPP_NAMESPACE::exchange( rhs.m_image, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -2237,8 +2372,19 @@ namespace VULKAN_HPP_NAMESPACE
Event() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Event() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Event( Event const & rhs ) = default; Event( Event const & rhs ) = default;
Event & operator=( Event const & rhs ) = default; Event & operator=( Event const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Event( Event && rhs ) = default; Event( Event && rhs ) = default;
Event & operator=( Event && rhs ) = default; Event & operator=( Event && rhs ) = default;
#else
Event( Event && rhs ) VULKAN_HPP_NOEXCEPT : m_event( VULKAN_HPP_NAMESPACE::exchange( rhs.m_event, {} ) ) {}
Event & operator=( Event && rhs ) VULKAN_HPP_NOEXCEPT
{
m_event = VULKAN_HPP_NAMESPACE::exchange( rhs.m_event, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -2336,8 +2482,19 @@ namespace VULKAN_HPP_NAMESPACE
CommandBuffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue CommandBuffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
CommandBuffer( CommandBuffer const & rhs ) = default; CommandBuffer( CommandBuffer const & rhs ) = default;
CommandBuffer & operator=( CommandBuffer const & rhs ) = default; CommandBuffer & operator=( CommandBuffer const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
CommandBuffer( CommandBuffer && rhs ) = default; CommandBuffer( CommandBuffer && rhs ) = default;
CommandBuffer & operator=( CommandBuffer && rhs ) = default; CommandBuffer & operator=( CommandBuffer && rhs ) = default;
#else
CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandBuffer, {} ) ) {}
CommandBuffer & operator=( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT
{
m_commandBuffer = VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandBuffer, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3493,8 +3650,19 @@ namespace VULKAN_HPP_NAMESPACE
DeviceMemory() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DeviceMemory() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DeviceMemory( DeviceMemory const & rhs ) = default; DeviceMemory( DeviceMemory const & rhs ) = default;
DeviceMemory & operator=( DeviceMemory const & rhs ) = default; DeviceMemory & operator=( DeviceMemory const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DeviceMemory( DeviceMemory && rhs ) = default; DeviceMemory( DeviceMemory && rhs ) = default;
DeviceMemory & operator=( DeviceMemory && rhs ) = default; DeviceMemory & operator=( DeviceMemory && rhs ) = default;
#else
DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( VULKAN_HPP_NAMESPACE::exchange( rhs.m_deviceMemory, {} ) ) {}
DeviceMemory & operator=( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT
{
m_deviceMemory = VULKAN_HPP_NAMESPACE::exchange( rhs.m_deviceMemory, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3592,8 +3760,19 @@ namespace VULKAN_HPP_NAMESPACE
BufferView() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue BufferView() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
BufferView( BufferView const & rhs ) = default; BufferView( BufferView const & rhs ) = default;
BufferView & operator=( BufferView const & rhs ) = default; BufferView & operator=( BufferView const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
BufferView( BufferView && rhs ) = default; BufferView( BufferView && rhs ) = default;
BufferView & operator=( BufferView && rhs ) = default; BufferView & operator=( BufferView && rhs ) = default;
#else
BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT : m_bufferView( VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferView, {} ) ) {}
BufferView & operator=( BufferView && rhs ) VULKAN_HPP_NOEXCEPT
{
m_bufferView = VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferView, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3691,8 +3870,19 @@ namespace VULKAN_HPP_NAMESPACE
CommandPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue CommandPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
CommandPool( CommandPool const & rhs ) = default; CommandPool( CommandPool const & rhs ) = default;
CommandPool & operator=( CommandPool const & rhs ) = default; CommandPool & operator=( CommandPool const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
CommandPool( CommandPool && rhs ) = default; CommandPool( CommandPool && rhs ) = default;
CommandPool & operator=( CommandPool && rhs ) = default; CommandPool & operator=( CommandPool && rhs ) = default;
#else
CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT : m_commandPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandPool, {} ) ) {}
CommandPool & operator=( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT
{
m_commandPool = VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandPool, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3790,8 +3980,19 @@ namespace VULKAN_HPP_NAMESPACE
PipelineCache() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue PipelineCache() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
PipelineCache( PipelineCache const & rhs ) = default; PipelineCache( PipelineCache const & rhs ) = default;
PipelineCache & operator=( PipelineCache const & rhs ) = default; PipelineCache & operator=( PipelineCache const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
PipelineCache( PipelineCache && rhs ) = default; PipelineCache( PipelineCache && rhs ) = default;
PipelineCache & operator=( PipelineCache && rhs ) = default; PipelineCache & operator=( PipelineCache && rhs ) = default;
#else
PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineCache, {} ) ) {}
PipelineCache & operator=( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT
{
m_pipelineCache = VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineCache, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3889,8 +4090,19 @@ namespace VULKAN_HPP_NAMESPACE
DescriptorPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DescriptorPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DescriptorPool( DescriptorPool const & rhs ) = default; DescriptorPool( DescriptorPool const & rhs ) = default;
DescriptorPool & operator=( DescriptorPool const & rhs ) = default; DescriptorPool & operator=( DescriptorPool const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DescriptorPool( DescriptorPool && rhs ) = default; DescriptorPool( DescriptorPool && rhs ) = default;
DescriptorPool & operator=( DescriptorPool && rhs ) = default; DescriptorPool & operator=( DescriptorPool && rhs ) = default;
#else
DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) ) {}
DescriptorPool & operator=( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT
{
m_descriptorPool = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorPool, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -3988,8 +4200,22 @@ namespace VULKAN_HPP_NAMESPACE
DescriptorSetLayout() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DescriptorSetLayout() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DescriptorSetLayout( DescriptorSetLayout const & rhs ) = default; DescriptorSetLayout( DescriptorSetLayout const & rhs ) = default;
DescriptorSetLayout & operator=( DescriptorSetLayout const & rhs ) = default; DescriptorSetLayout & operator=( DescriptorSetLayout const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DescriptorSetLayout( DescriptorSetLayout && rhs ) = default; DescriptorSetLayout( DescriptorSetLayout && rhs ) = default;
DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) = default; DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) = default;
#else
DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT
: m_descriptorSetLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} ) )
{
}
DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT
{
m_descriptorSetLayout = VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4090,8 +4316,19 @@ namespace VULKAN_HPP_NAMESPACE
Framebuffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Framebuffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Framebuffer( Framebuffer const & rhs ) = default; Framebuffer( Framebuffer const & rhs ) = default;
Framebuffer & operator=( Framebuffer const & rhs ) = default; Framebuffer & operator=( Framebuffer const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Framebuffer( Framebuffer && rhs ) = default; Framebuffer( Framebuffer && rhs ) = default;
Framebuffer & operator=( Framebuffer && rhs ) = default; Framebuffer & operator=( Framebuffer && rhs ) = default;
#else
Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT : m_framebuffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_framebuffer, {} ) ) {}
Framebuffer & operator=( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT
{
m_framebuffer = VULKAN_HPP_NAMESPACE::exchange( rhs.m_framebuffer, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4189,8 +4426,19 @@ namespace VULKAN_HPP_NAMESPACE
ImageView() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue ImageView() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
ImageView( ImageView const & rhs ) = default; ImageView( ImageView const & rhs ) = default;
ImageView & operator=( ImageView const & rhs ) = default; ImageView & operator=( ImageView const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
ImageView( ImageView && rhs ) = default; ImageView( ImageView && rhs ) = default;
ImageView & operator=( ImageView && rhs ) = default; ImageView & operator=( ImageView && rhs ) = default;
#else
ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT : m_imageView( VULKAN_HPP_NAMESPACE::exchange( rhs.m_imageView, {} ) ) {}
ImageView & operator=( ImageView && rhs ) VULKAN_HPP_NOEXCEPT
{
m_imageView = VULKAN_HPP_NAMESPACE::exchange( rhs.m_imageView, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4288,8 +4536,19 @@ namespace VULKAN_HPP_NAMESPACE
PrivateDataSlot() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue PrivateDataSlot() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
PrivateDataSlot( PrivateDataSlot const & rhs ) = default; PrivateDataSlot( PrivateDataSlot const & rhs ) = default;
PrivateDataSlot & operator=( PrivateDataSlot const & rhs ) = default; PrivateDataSlot & operator=( PrivateDataSlot const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
PrivateDataSlot( PrivateDataSlot && rhs ) = default; PrivateDataSlot( PrivateDataSlot && rhs ) = default;
PrivateDataSlot & operator=( PrivateDataSlot && rhs ) = default; PrivateDataSlot & operator=( PrivateDataSlot && rhs ) = default;
#else
PrivateDataSlot( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( VULKAN_HPP_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ) ) {}
PrivateDataSlot & operator=( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT
{
m_privateDataSlot = VULKAN_HPP_NAMESPACE::exchange( rhs.m_privateDataSlot, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4383,8 +4642,19 @@ namespace VULKAN_HPP_NAMESPACE
RenderPass() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue RenderPass() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
RenderPass( RenderPass const & rhs ) = default; RenderPass( RenderPass const & rhs ) = default;
RenderPass & operator=( RenderPass const & rhs ) = default; RenderPass & operator=( RenderPass const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
RenderPass( RenderPass && rhs ) = default; RenderPass( RenderPass && rhs ) = default;
RenderPass & operator=( RenderPass && rhs ) = default; RenderPass & operator=( RenderPass && rhs ) = default;
#else
RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT : m_renderPass( VULKAN_HPP_NAMESPACE::exchange( rhs.m_renderPass, {} ) ) {}
RenderPass & operator=( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT
{
m_renderPass = VULKAN_HPP_NAMESPACE::exchange( rhs.m_renderPass, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4482,8 +4752,19 @@ namespace VULKAN_HPP_NAMESPACE
Sampler() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Sampler() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Sampler( Sampler const & rhs ) = default; Sampler( Sampler const & rhs ) = default;
Sampler & operator=( Sampler const & rhs ) = default; Sampler & operator=( Sampler const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Sampler( Sampler && rhs ) = default; Sampler( Sampler && rhs ) = default;
Sampler & operator=( Sampler && rhs ) = default; Sampler & operator=( Sampler && rhs ) = default;
#else
Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT : m_sampler( VULKAN_HPP_NAMESPACE::exchange( rhs.m_sampler, {} ) ) {}
Sampler & operator=( Sampler && rhs ) VULKAN_HPP_NOEXCEPT
{
m_sampler = VULKAN_HPP_NAMESPACE::exchange( rhs.m_sampler, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4581,8 +4862,22 @@ namespace VULKAN_HPP_NAMESPACE
SamplerYcbcrConversion() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue SamplerYcbcrConversion() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
SamplerYcbcrConversion( SamplerYcbcrConversion const & rhs ) = default; SamplerYcbcrConversion( SamplerYcbcrConversion const & rhs ) = default;
SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & rhs ) = default; SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) = default; SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) = default;
SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) = default; SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) = default;
#else
SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT
: m_samplerYcbcrConversion( VULKAN_HPP_NAMESPACE::exchange( rhs.m_samplerYcbcrConversion, {} ) )
{
}
SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT
{
m_samplerYcbcrConversion = VULKAN_HPP_NAMESPACE::exchange( rhs.m_samplerYcbcrConversion, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4686,8 +4981,22 @@ namespace VULKAN_HPP_NAMESPACE
SemaphoreSciSyncPoolNV() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue SemaphoreSciSyncPoolNV() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
SemaphoreSciSyncPoolNV( SemaphoreSciSyncPoolNV const & rhs ) = default; SemaphoreSciSyncPoolNV( SemaphoreSciSyncPoolNV const & rhs ) = default;
SemaphoreSciSyncPoolNV & operator=( SemaphoreSciSyncPoolNV const & rhs ) = default; SemaphoreSciSyncPoolNV & operator=( SemaphoreSciSyncPoolNV const & rhs ) = default;
# if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
SemaphoreSciSyncPoolNV( SemaphoreSciSyncPoolNV && rhs ) = default; SemaphoreSciSyncPoolNV( SemaphoreSciSyncPoolNV && rhs ) = default;
SemaphoreSciSyncPoolNV & operator=( SemaphoreSciSyncPoolNV && rhs ) = default; SemaphoreSciSyncPoolNV & operator=( SemaphoreSciSyncPoolNV && rhs ) = default;
# else
SemaphoreSciSyncPoolNV( SemaphoreSciSyncPoolNV && rhs ) VULKAN_HPP_NOEXCEPT
: m_semaphoreSciSyncPoolNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_semaphoreSciSyncPoolNV, {} ) )
{
}
SemaphoreSciSyncPoolNV & operator=( SemaphoreSciSyncPoolNV && rhs ) VULKAN_HPP_NOEXCEPT
{
m_semaphoreSciSyncPoolNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_semaphoreSciSyncPoolNV, {} );
return *this;
}
# endif
VULKAN_HPP_CONSTEXPR SemaphoreSciSyncPoolNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR SemaphoreSciSyncPoolNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4783,8 +5092,19 @@ namespace VULKAN_HPP_NAMESPACE
Queue() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Queue() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Queue( Queue const & rhs ) = default; Queue( Queue const & rhs ) = default;
Queue & operator=( Queue const & rhs ) = default; Queue & operator=( Queue const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Queue( Queue && rhs ) = default; Queue( Queue && rhs ) = default;
Queue & operator=( Queue && rhs ) = default; Queue & operator=( Queue && rhs ) = default;
#else
Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT : m_queue( VULKAN_HPP_NAMESPACE::exchange( rhs.m_queue, {} ) ) {}
Queue & operator=( Queue && rhs ) VULKAN_HPP_NOEXCEPT
{
m_queue = VULKAN_HPP_NAMESPACE::exchange( rhs.m_queue, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -4984,8 +5304,19 @@ namespace VULKAN_HPP_NAMESPACE
Device() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Device() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Device( Device const & rhs ) = default; Device( Device const & rhs ) = default;
Device & operator=( Device const & rhs ) = default; Device & operator=( Device const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Device( Device && rhs ) = default; Device( Device && rhs ) = default;
Device & operator=( Device && rhs ) = default; Device & operator=( Device && rhs ) = default;
#else
Device( Device && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) {}
Device & operator=( Device && rhs ) VULKAN_HPP_NOEXCEPT
{
m_device = VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -7138,8 +7469,19 @@ namespace VULKAN_HPP_NAMESPACE
DisplayModeKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue DisplayModeKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DisplayModeKHR( DisplayModeKHR const & rhs ) = default; DisplayModeKHR( DisplayModeKHR const & rhs ) = default;
DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) = default; DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DisplayModeKHR( DisplayModeKHR && rhs ) = default; DisplayModeKHR( DisplayModeKHR && rhs ) = default;
DisplayModeKHR & operator=( DisplayModeKHR && rhs ) = default; DisplayModeKHR & operator=( DisplayModeKHR && rhs ) = default;
#else
DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ) ) {}
DisplayModeKHR & operator=( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT
{
m_displayModeKHR = VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayModeKHR, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -7237,8 +7579,19 @@ namespace VULKAN_HPP_NAMESPACE
PhysicalDevice() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue PhysicalDevice() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
PhysicalDevice( PhysicalDevice const & rhs ) = default; PhysicalDevice( PhysicalDevice const & rhs ) = default;
PhysicalDevice & operator=( PhysicalDevice const & rhs ) = default; PhysicalDevice & operator=( PhysicalDevice const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
PhysicalDevice( PhysicalDevice && rhs ) = default; PhysicalDevice( PhysicalDevice && rhs ) = default;
PhysicalDevice & operator=( PhysicalDevice && rhs ) = default; PhysicalDevice & operator=( PhysicalDevice && rhs ) = default;
#else
PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) {}
PhysicalDevice & operator=( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT
{
m_physicalDevice = VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -8136,8 +8489,19 @@ namespace VULKAN_HPP_NAMESPACE
Instance() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue Instance() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Instance( Instance const & rhs ) = default; Instance( Instance const & rhs ) = default;
Instance & operator=( Instance const & rhs ) = default; Instance & operator=( Instance const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Instance( Instance && rhs ) = default; Instance( Instance && rhs ) = default;
Instance & operator=( Instance && rhs ) = default; Instance & operator=( Instance && rhs ) = default;
#else
Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT : m_instance( VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} ) ) {}
Instance & operator=( Instance && rhs ) VULKAN_HPP_NOEXCEPT
{
m_instance = VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
@ -8482,8 +8846,19 @@ namespace VULKAN_HPP_NAMESPACE
ShaderModule() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue ShaderModule() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
ShaderModule( ShaderModule const & rhs ) = default; ShaderModule( ShaderModule const & rhs ) = default;
ShaderModule & operator=( ShaderModule const & rhs ) = default; ShaderModule & operator=( ShaderModule const & rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
ShaderModule( ShaderModule && rhs ) = default; ShaderModule( ShaderModule && rhs ) = default;
ShaderModule & operator=( ShaderModule && rhs ) = default; ShaderModule & operator=( ShaderModule && rhs ) = default;
#else
ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT : m_shaderModule( VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderModule, {} ) ) {}
ShaderModule & operator=( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT
{
m_shaderModule = VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderModule, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}

326
vulkan/vulkansc_raii.hpp
View File

@ -9,7 +9,7 @@
#define VULKAN_RAII_HPP #define VULKAN_RAII_HPP
#include <memory> // std::unique_ptr #include <memory> // std::unique_ptr
#include <utility> // std::exchange, std::forward #include <utility> // std::forward
#include <vulkan/vulkansc.hpp> #include <vulkan/vulkansc.hpp>
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
@ -17,18 +17,6 @@ namespace VULKAN_HPP_NAMESPACE
{ {
namespace VULKAN_HPP_RAII_NAMESPACE namespace VULKAN_HPP_RAII_NAMESPACE
{ {
# if ( 14 <= VULKAN_HPP_CPP_VERSION )
using std::exchange;
# else
template <class T, class U = T>
VULKAN_HPP_CONSTEXPR_14 VULKAN_HPP_INLINE T exchange( T & obj, U && newValue )
{
T oldValue = std::move( obj );
obj = std::forward<U>( newValue );
return oldValue;
}
# endif
template <class T> template <class T>
class CreateReturnType class CreateReturnType
{ {
@ -1251,8 +1239,8 @@ namespace VULKAN_HPP_NAMESPACE
Instance( Instance const & ) = delete; Instance( Instance const & ) = delete;
Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT
: m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) ) : m_instance( VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( rhs.m_dispatcher.release() ) , m_dispatcher( rhs.m_dispatcher.release() )
{ {
} }
@ -1295,7 +1283,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_instance, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_instance, nullptr );
} }
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
@ -1383,8 +1371,8 @@ namespace VULKAN_HPP_NAMESPACE
PhysicalDevice( PhysicalDevice const & rhs ) : m_physicalDevice( rhs.m_physicalDevice ), m_dispatcher( rhs.m_dispatcher ) {} PhysicalDevice( PhysicalDevice const & rhs ) : m_physicalDevice( rhs.m_physicalDevice ), m_dispatcher( rhs.m_dispatcher ) {}
PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT
: m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) : m_physicalDevice( VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -1424,7 +1412,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::PhysicalDevice release() VULKAN_HPP_NAMESPACE::PhysicalDevice release()
{ {
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_physicalDevice, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_physicalDevice, nullptr );
} }
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
@ -1688,8 +1676,8 @@ namespace VULKAN_HPP_NAMESPACE
Device( Device const & ) = delete; Device( Device const & ) = delete;
Device( Device && rhs ) VULKAN_HPP_NOEXCEPT Device( Device && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( rhs.m_dispatcher.release() ) , m_dispatcher( rhs.m_dispatcher.release() )
{ {
} }
@ -1732,7 +1720,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_device, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_device, nullptr );
} }
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
@ -2150,10 +2138,10 @@ namespace VULKAN_HPP_NAMESPACE
Buffer( Buffer const & ) = delete; Buffer( Buffer const & ) = delete;
Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_buffer, {} ) ) , m_buffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_buffer, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -2199,7 +2187,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_buffer, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_buffer, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -2275,10 +2263,10 @@ namespace VULKAN_HPP_NAMESPACE
BufferView( BufferView const & ) = delete; BufferView( BufferView const & ) = delete;
BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_bufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferView, {} ) ) , m_bufferView( VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferView, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -2324,7 +2312,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_bufferView, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_bufferView, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -2394,10 +2382,10 @@ namespace VULKAN_HPP_NAMESPACE
CommandPool( CommandPool const & ) = delete; CommandPool( CommandPool const & ) = delete;
CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_commandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ) ) , m_commandPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandPool, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -2443,7 +2431,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_commandPool, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_commandPool, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -2508,10 +2496,10 @@ namespace VULKAN_HPP_NAMESPACE
CommandBuffer( CommandBuffer const & ) = delete; CommandBuffer( CommandBuffer const & ) = delete;
CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_commandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ) ) , m_commandPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandPool, {} ) )
, m_commandBuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandBuffer, {} ) ) , m_commandBuffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandBuffer, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -2557,7 +2545,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_commandPool = nullptr; m_commandPool = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_commandBuffer, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_commandBuffer, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -3059,10 +3047,10 @@ namespace VULKAN_HPP_NAMESPACE
DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & ) = delete; DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & ) = delete;
DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT
: m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) ) : m_instance( VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} ) )
, m_messenger( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_messenger, {} ) ) , m_messenger( VULKAN_HPP_NAMESPACE::exchange( rhs.m_messenger, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -3109,7 +3097,7 @@ namespace VULKAN_HPP_NAMESPACE
m_instance = nullptr; m_instance = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_messenger, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_messenger, nullptr );
} }
VULKAN_HPP_NAMESPACE::Instance getInstance() const VULKAN_HPP_NAMESPACE::Instance getInstance() const
@ -3179,10 +3167,10 @@ namespace VULKAN_HPP_NAMESPACE
DescriptorPool( DescriptorPool const & ) = delete; DescriptorPool( DescriptorPool const & ) = delete;
DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_descriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) ) , m_descriptorPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -3229,7 +3217,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_descriptorPool, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_descriptorPool, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -3289,10 +3277,10 @@ namespace VULKAN_HPP_NAMESPACE
DescriptorSet( DescriptorSet const & ) = delete; DescriptorSet( DescriptorSet const & ) = delete;
DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_descriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) ) , m_descriptorPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) )
, m_descriptorSet( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSet, {} ) ) , m_descriptorSet( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSet, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -3340,7 +3328,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_descriptorPool = nullptr; m_descriptorPool = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_descriptorSet, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_descriptorSet, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -3436,10 +3424,10 @@ namespace VULKAN_HPP_NAMESPACE
DescriptorSetLayout( DescriptorSetLayout const & ) = delete; DescriptorSetLayout( DescriptorSetLayout const & ) = delete;
DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_descriptorSetLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} ) ) , m_descriptorSetLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -3486,7 +3474,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_descriptorSetLayout, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_descriptorSetLayout, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -3556,10 +3544,10 @@ namespace VULKAN_HPP_NAMESPACE
DeviceMemory( DeviceMemory const & ) = delete; DeviceMemory( DeviceMemory const & ) = delete;
DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_memory( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_memory, {} ) ) , m_memory( VULKAN_HPP_NAMESPACE::exchange( rhs.m_memory, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -3605,7 +3593,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_memory, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_memory, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -3680,9 +3668,9 @@ namespace VULKAN_HPP_NAMESPACE
DisplayKHR( DisplayKHR const & ) = delete; DisplayKHR( DisplayKHR const & ) = delete;
DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT
: m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) : m_physicalDevice( VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) )
, m_display( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, {} ) ) , m_display( VULKAN_HPP_NAMESPACE::exchange( rhs.m_display, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -3724,7 +3712,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
m_physicalDevice = nullptr; m_physicalDevice = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_display, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_display, nullptr );
} }
VULKAN_HPP_NAMESPACE::PhysicalDevice getPhysicalDevice() const VULKAN_HPP_NAMESPACE::PhysicalDevice getPhysicalDevice() const
@ -3832,9 +3820,9 @@ namespace VULKAN_HPP_NAMESPACE
DisplayModeKHR( DisplayModeKHR const & rhs ) : m_displayModeKHR( rhs.m_displayModeKHR ), m_dispatcher( rhs.m_dispatcher ) {} DisplayModeKHR( DisplayModeKHR const & rhs ) : m_displayModeKHR( rhs.m_displayModeKHR ), m_dispatcher( rhs.m_dispatcher ) {}
DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT
: m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) : m_physicalDevice( VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) )
, m_displayModeKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ) ) , m_displayModeKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -3877,7 +3865,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
m_physicalDevice = nullptr; m_physicalDevice = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_displayModeKHR, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_displayModeKHR, nullptr );
} }
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
@ -3944,10 +3932,10 @@ namespace VULKAN_HPP_NAMESPACE
Event( Event const & ) = delete; Event( Event const & ) = delete;
Event( Event && rhs ) VULKAN_HPP_NOEXCEPT Event( Event && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_event, {} ) ) , m_event( VULKAN_HPP_NAMESPACE::exchange( rhs.m_event, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -3993,7 +3981,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_event, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_event, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -4090,10 +4078,10 @@ namespace VULKAN_HPP_NAMESPACE
Fence( Fence const & ) = delete; Fence( Fence const & ) = delete;
Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_fence, {} ) ) , m_fence( VULKAN_HPP_NAMESPACE::exchange( rhs.m_fence, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -4139,7 +4127,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_fence, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_fence, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -4213,10 +4201,10 @@ namespace VULKAN_HPP_NAMESPACE
Framebuffer( Framebuffer const & ) = delete; Framebuffer( Framebuffer const & ) = delete;
Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_framebuffer, {} ) ) , m_framebuffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_framebuffer, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -4262,7 +4250,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_framebuffer, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_framebuffer, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -4332,10 +4320,10 @@ namespace VULKAN_HPP_NAMESPACE
Image( Image const & ) = delete; Image( Image const & ) = delete;
Image( Image && rhs ) VULKAN_HPP_NOEXCEPT Image( Image && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_image, {} ) ) , m_image( VULKAN_HPP_NAMESPACE::exchange( rhs.m_image, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -4381,7 +4369,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_image, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_image, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -4464,10 +4452,10 @@ namespace VULKAN_HPP_NAMESPACE
ImageView( ImageView const & ) = delete; ImageView( ImageView const & ) = delete;
ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_imageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_imageView, {} ) ) , m_imageView( VULKAN_HPP_NAMESPACE::exchange( rhs.m_imageView, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -4513,7 +4501,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_imageView, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_imageView, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -4583,10 +4571,10 @@ namespace VULKAN_HPP_NAMESPACE
PipelineCache( PipelineCache const & ) = delete; PipelineCache( PipelineCache const & ) = delete;
PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_pipelineCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineCache, {} ) ) , m_pipelineCache( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineCache, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -4633,7 +4621,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_pipelineCache, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_pipelineCache, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -4738,11 +4726,11 @@ namespace VULKAN_HPP_NAMESPACE
Pipeline( Pipeline const & ) = delete; Pipeline( Pipeline const & ) = delete;
Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipeline, {} ) ) , m_pipeline( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipeline, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_constructorSuccessCode( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} ) ) , m_constructorSuccessCode( VULKAN_HPP_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -4791,7 +4779,7 @@ namespace VULKAN_HPP_NAMESPACE
m_allocator = nullptr; m_allocator = nullptr;
m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_pipeline, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_pipeline, nullptr );
} }
VULKAN_HPP_NAMESPACE::Result getConstructorSuccessCode() const VULKAN_HPP_NAMESPACE::Result getConstructorSuccessCode() const
@ -4906,10 +4894,10 @@ namespace VULKAN_HPP_NAMESPACE
PipelineLayout( PipelineLayout const & ) = delete; PipelineLayout( PipelineLayout const & ) = delete;
PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_pipelineLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ) ) , m_pipelineLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -4956,7 +4944,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_pipelineLayout, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_pipelineLayout, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -5026,10 +5014,10 @@ namespace VULKAN_HPP_NAMESPACE
PrivateDataSlot( PrivateDataSlot const & ) = delete; PrivateDataSlot( PrivateDataSlot const & ) = delete;
PrivateDataSlot( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT PrivateDataSlot( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_privateDataSlot( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ) ) , m_privateDataSlot( VULKAN_HPP_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -5076,7 +5064,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_privateDataSlot, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_privateDataSlot, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -5146,10 +5134,10 @@ namespace VULKAN_HPP_NAMESPACE
QueryPool( QueryPool const & ) = delete; QueryPool( QueryPool const & ) = delete;
QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_queryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queryPool, {} ) ) , m_queryPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_queryPool, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -5195,7 +5183,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_queryPool, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_queryPool, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -5286,8 +5274,8 @@ namespace VULKAN_HPP_NAMESPACE
Queue( Queue const & rhs ) : m_queue( rhs.m_queue ), m_dispatcher( rhs.m_dispatcher ) {} Queue( Queue const & rhs ) : m_queue( rhs.m_queue ), m_dispatcher( rhs.m_dispatcher ) {}
Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT
: m_queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queue, {} ) ) : m_queue( VULKAN_HPP_NAMESPACE::exchange( rhs.m_queue, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -5327,7 +5315,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Queue release() VULKAN_HPP_NAMESPACE::Queue release()
{ {
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_queue, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_queue, nullptr );
} }
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
@ -5428,10 +5416,10 @@ namespace VULKAN_HPP_NAMESPACE
RenderPass( RenderPass const & ) = delete; RenderPass( RenderPass const & ) = delete;
RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_renderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_renderPass, {} ) ) , m_renderPass( VULKAN_HPP_NAMESPACE::exchange( rhs.m_renderPass, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -5477,7 +5465,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_renderPass, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_renderPass, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -5551,10 +5539,10 @@ namespace VULKAN_HPP_NAMESPACE
Sampler( Sampler const & ) = delete; Sampler( Sampler const & ) = delete;
Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_sampler, {} ) ) , m_sampler( VULKAN_HPP_NAMESPACE::exchange( rhs.m_sampler, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -5600,7 +5588,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_sampler, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_sampler, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -5670,10 +5658,10 @@ namespace VULKAN_HPP_NAMESPACE
SamplerYcbcrConversion( SamplerYcbcrConversion const & ) = delete; SamplerYcbcrConversion( SamplerYcbcrConversion const & ) = delete;
SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_ycbcrConversion( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} ) ) , m_ycbcrConversion( VULKAN_HPP_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -5720,7 +5708,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_ycbcrConversion, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_ycbcrConversion, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -5790,10 +5778,10 @@ namespace VULKAN_HPP_NAMESPACE
Semaphore( Semaphore const & ) = delete; Semaphore( Semaphore const & ) = delete;
Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphore, {} ) ) , m_semaphore( VULKAN_HPP_NAMESPACE::exchange( rhs.m_semaphore, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -5839,7 +5827,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_semaphore, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_semaphore, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -5914,10 +5902,10 @@ namespace VULKAN_HPP_NAMESPACE
SemaphoreSciSyncPoolNV( SemaphoreSciSyncPoolNV const & ) = delete; SemaphoreSciSyncPoolNV( SemaphoreSciSyncPoolNV const & ) = delete;
SemaphoreSciSyncPoolNV( SemaphoreSciSyncPoolNV && rhs ) VULKAN_HPP_NOEXCEPT SemaphoreSciSyncPoolNV( SemaphoreSciSyncPoolNV && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_semaphorePool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphorePool, {} ) ) , m_semaphorePool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_semaphorePool, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -5964,7 +5952,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_semaphorePool, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_semaphorePool, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -6035,10 +6023,10 @@ namespace VULKAN_HPP_NAMESPACE
ShaderModule( ShaderModule const & ) = delete; ShaderModule( ShaderModule const & ) = delete;
ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_shaderModule( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shaderModule, {} ) ) , m_shaderModule( VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderModule, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -6084,7 +6072,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_shaderModule, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_shaderModule, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const
@ -6163,10 +6151,10 @@ namespace VULKAN_HPP_NAMESPACE
SurfaceKHR( SurfaceKHR const & ) = delete; SurfaceKHR( SurfaceKHR const & ) = delete;
SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT
: m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) ) : m_instance( VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} ) )
, m_surface( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surface, {} ) ) , m_surface( VULKAN_HPP_NAMESPACE::exchange( rhs.m_surface, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -6212,7 +6200,7 @@ namespace VULKAN_HPP_NAMESPACE
m_instance = nullptr; m_instance = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_surface, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_surface, nullptr );
} }
VULKAN_HPP_NAMESPACE::Instance getInstance() const VULKAN_HPP_NAMESPACE::Instance getInstance() const
@ -6282,10 +6270,10 @@ namespace VULKAN_HPP_NAMESPACE
SwapchainKHR( SwapchainKHR const & ) = delete; SwapchainKHR( SwapchainKHR const & ) = delete;
SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT
: m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) )
, m_swapchain( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchain, {} ) ) , m_swapchain( VULKAN_HPP_NAMESPACE::exchange( rhs.m_swapchain, {} ) )
, m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) )
, m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
{ {
} }
@ -6331,7 +6319,7 @@ namespace VULKAN_HPP_NAMESPACE
m_device = nullptr; m_device = nullptr;
m_allocator = nullptr; m_allocator = nullptr;
m_dispatcher = nullptr; m_dispatcher = nullptr;
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_swapchain, nullptr ); return VULKAN_HPP_NAMESPACE::exchange( m_swapchain, nullptr );
} }
VULKAN_HPP_NAMESPACE::Device getDevice() const VULKAN_HPP_NAMESPACE::Device getDevice() const