AuroraMiddleware/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp synced 2024-11-23 20:50:05 +00:00
Code Issues Releases Wiki Activity

Non raii handles move exchange (#1929)

Browse Source 
* Add move semantics for non-raii hpp handles. (#1919)

* Updated generated vulkan/* files
This commit is contained in:
Nikolai Siukosev 2024-07-23 11:55:09 +04:00 committed by GitHub
parent cdcde2bd0b
commit ae1eb5f449
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 1685 additions and 623 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
README.md
View File

@ -892,6 +892,10 @@ When this is not externally defined and `VULKAN_HPP_CPP_VERSION` is at least `23
By default, the member `m_mask` of the `Flags` class template is private. This is to prevent accidentally setting a `Flags` with some inappropriate value. But it also prevents using a `Flags`, or a structure holding a `Flags`, to be used as a non-type template parameter. If you really need that functionality, and accept the reduced security, you can use this define to change the access specifier for `m_mask` from private to public, which allows using a `Flags` as a non-type template parameter.
#### VULKAN_HPP_HANDLES_MOVE_EXCHANGE
This define can be used to enable `m_handle = exchange( rhs.m_handle, {} )` in move constructors of Vulkan-Hpp handles, which default-initializes the `rhs` underlying value. By default Vulkan-Hpp handles behave like trivial types -- move constructors copying value.
#### VULKAN_HPP_HASH_COMBINE
This define can be used to specify your own hash combiner function. In order to determine the hash of a vk-structure, the hashes of the members of that struct are to be combined. This is done by this define, which by default is identical to what the function `boost::hash_combine()` does. It gets the type of the to-be-combined value, the seed, which is the combined value up to that point, and finally the to-be-combined value. This hash calculation determines a "shallow" hash, as it takes the hashes of any pointer in a structure, and not the hash of a pointed-to value.

47
VulkanHppGenerator.cpp
View File

@ -458,6 +458,7 @@ ${UniqueHandle}
${DispatchLoaderBase}
${DispatchLoaderStatic}
${Exchange}
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
${ObjectDestroy}
${ObjectFree}
@ -532,6 +533,7 @@ ${DispatchLoaderDynamic}
{ "DispatchLoaderStatic", generateDispatchLoaderStatic() },
{ "DynamicLoader", readSnippet( "DynamicLoader.hpp" ) },
{ "Exceptions", readSnippet( "Exceptions.hpp" ) },
{ "Exchange", readSnippet( "Exchange.hpp" ) },
{ "headerVersion", m_version },
{ "includes", replaceWithMap( readSnippet( "includes.hpp" ), { { "vulkan_h", ( m_api == "vulkan" ) ? "vulkan.h" : "vulkan_sc_core.h" } } ) },
{ "licenseHeader", m_vulkanLicenseHeader },
@ -582,7 +584,7 @@ void VulkanHppGenerator::generateRAIIHppFile() const
#define VULKAN_RAII_HPP
#include <memory> // std::unique_ptr
#include <utility> // std::exchange, std::forward
#include <utility> // std::forward
#include <vulkan/${api}.hpp>
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
@ -590,18 +592,6 @@ namespace VULKAN_HPP_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>
class CreateReturnType
{
@ -5751,6 +5741,7 @@ std::string VulkanHppGenerator::generateCppModuleUsings() const
auto const hardCodedEnhancedModeTypes = std::array{ "ArrayProxy", "ArrayProxyNoTemporaries", "StridedArrayProxy", "Optional", "StructureChain" };
auto const hardCodedSmartHandleTypes = std::array{ "ObjectDestroy", "ObjectFree", "ObjectRelease", "PoolFree", "ObjectDestroyShared",
"ObjectFreeShared", "ObjectReleaseShared", "PoolFreeShared", "SharedHandle", "UniqueHandle" };
auto const hardCodedFunctions = std::array{ "exchange" };
auto usings = std::string{ R"( //=====================================
//=== HARDCODED TYPEs AND FUNCTIONs ===
@ -5794,6 +5785,11 @@ std::string VulkanHppGenerator::generateCppModuleUsings() const
const auto [enterNoSmartHandle, leaveNoSmartHandle] = generateProtection( "VULKAN_HPP_NO_SMART_HANDLE", false );
usings += "\n" + enterNoSmartHandle + noSmartHandleUsings + leaveNoSmartHandle + "\n";
for ( auto const& functionName : hardCodedFunctions )
{
usings += "\n" + replaceWithMap( usingTemplate, { { "className", std::string{ functionName } } } );
}
// now generate baseTypes
auto baseTypes = std::string{ R"(
//==================
@ -5906,7 +5902,6 @@ std::string VulkanHppGenerator::generateCppModuleRaiiUsings() const
//=== RAII HARDCODED ===
//======================
using VULKAN_HPP_RAII_NAMESPACE::exchange;
using VULKAN_HPP_RAII_NAMESPACE::Context;
using VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher;
using VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher;
@ -7823,8 +7818,20 @@ ${enter} class ${className}
${className}() VULKAN_HPP_NOEXCEPT {}; // = default - try to workaround a compiler issue
${className}( ${className} const & rhs ) = default;
${className} & operator=( ${className} const & rhs ) = default;
#if !defined(VULKAN_HPP_HANDLES_MOVE_EXCHANGE)
${className}( ${className} && rhs ) = default;
${className} & operator=( ${className} && rhs ) = default;
#else
${className}( ${className} && rhs ) VULKAN_HPP_NOEXCEPT
: m_${memberName}( VULKAN_HPP_NAMESPACE::exchange( rhs.m_${memberName}, {} ) )
{}
${className} & operator=( ${className} && rhs ) VULKAN_HPP_NOEXCEPT
{
m_${memberName} = VULKAN_HPP_NAMESPACE::exchange( rhs.m_${memberName}, {} );
return *this;
}
#endif
VULKAN_HPP_CONSTEXPR ${className}( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{}
@ -9939,7 +9946,7 @@ std::tuple<std::string, std::string, std::string, std::string, std::string, std:
if ( !memberName.empty() )
{
clearMembers += "\n m_" + memberName + " = nullptr;";
moveConstructorInitializerList += "m_" + memberName + "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + memberName + ", {} ) ), ";
moveConstructorInitializerList += "m_" + memberName + "( VULKAN_HPP_NAMESPACE::exchange( rhs.m_" + memberName + ", {} ) ), ";
moveAssignmentInstructions += "\n std::swap( m_" + memberName + ", rhs.m_" + memberName + " );";
memberVariables += "\n " + memberType + " m_" + memberName + " = {};";
swapMembers += "\n std::swap( m_" + memberName + ", rhs.m_" + memberName + " );";
@ -9966,14 +9973,14 @@ std::tuple<std::string, std::string, std::string, std::string, std::string, std:
std::string frontName = handle.second.constructorIts.front()->second.params.front().name;
clearMembers += "\n m_" + frontName + " = nullptr;";
moveConstructorInitializerList = "m_" + frontName + "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + frontName + ", {} ) ), ";
moveConstructorInitializerList = "m_" + frontName + "( VULKAN_HPP_NAMESPACE::exchange( rhs.m_" + frontName + ", {} ) ), ";
moveAssignmentInstructions = "\n std::swap( m_" + frontName + ", rhs.m_" + frontName + " );";
memberVariables = "\n VULKAN_HPP_NAMESPACE::" + stripPrefix( frontType, "Vk" ) + " m_" + frontName + " = {};";
swapMembers = "\n std::swap( m_" + frontName + ", rhs.m_" + frontName + " );";
releaseMembers += "\n m_" + frontName + " = nullptr;";
}
clearMembers += "\n m_" + handleName + " = nullptr;";
moveConstructorInitializerList += "m_" + handleName + "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + handleName + ", {} ) ), ";
moveConstructorInitializerList += "m_" + handleName + "( VULKAN_HPP_NAMESPACE::exchange( rhs.m_" + handleName + ", {} ) ), ";
moveAssignmentInstructions += "\n std::swap( m_" + handleName + ", rhs.m_" + handleName + " );";
memberVariables += "\n " + generateNamespacedType( handle.first ) + " m_" + handleName + " = {};";
swapMembers += "\n std::swap( m_" + handleName + ", rhs.m_" + handleName + " );";
@ -9985,7 +9992,7 @@ std::tuple<std::string, std::string, std::string, std::string, std::string, std:
memberVariables += "\n VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown;";
swapMembers += "\n std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode );";
moveConstructorInitializerList +=
"m_constructorSuccessCode( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} ) ), ";
"m_constructorSuccessCode( VULKAN_HPP_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} ) ), ";
moveAssignmentInstructions += "\n std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode );";
releaseMembers += "\n m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown;";
}
@ -10009,7 +10016,7 @@ std::tuple<std::string, std::string, std::string, std::string, std::string, std:
clearMembers += "\n m_dispatcher = nullptr;";
swapMembers += "\n std::swap( m_dispatcher, rhs.m_dispatcher );";
releaseMembers += "\n m_dispatcher = nullptr;";
releaseMembers += "\n return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_" + handleName + ", nullptr );";
releaseMembers += "\n return VULKAN_HPP_NAMESPACE::exchange( m_" + handleName + ", nullptr );";
if ( ( handle.first == "VkInstance" ) || ( handle.first == "VkDevice" ) )
{
@ -10017,7 +10024,7 @@ std::tuple<std::string, std::string, std::string, std::string, std::string, std:
}
else
{
moveConstructorInitializerList += "m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )";
moveConstructorInitializerList += "m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )";
}
moveAssignmentInstructions += "\n std::swap( m_dispatcher, rhs.m_dispatcher );";

11
snippets/Exchange.hpp Normal file
View File

@ -0,0 +1,11 @@
#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

1
snippets/includes.hpp
View File

@ -2,6 +2,7 @@
#include <array> // ArrayWrapperND
#include <string.h> // strnlen
#include <string> // std::string
#include <utility> // std::exchange
#include <vulkan/${vulkan_h}>
#include <vulkan/vulkan_hpp_macros.hpp>

1
tests/CMakeLists.txt
View File

@ -30,6 +30,7 @@ add_subdirectory( ExtensionInspection )
add_subdirectory( Flags )
add_subdirectory( FormatTraits )
add_subdirectory( Handles )
add_subdirectory( HandlesMoveExchange )
add_subdirectory( Hash )
add_subdirectory( NoExceptions )
if( ( "cxx_std_23" IN_LIST CMAKE_CXX_COMPILE_FEATURES ) AND NOT ( ( CMAKE_CXX_COMPILER_ID STREQUAL "Clang" ) AND ( CMAKE_CXX_COMPILER_VERSION VERSION_LESS 15.0 ) ) )

19
tests/HandlesMoveExchange/CMakeLists.txt Normal file
View File

@ -0,0 +1,19 @@
# Copyright(c) 2024, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
if( NOT VULKAN_HPP_TESTS_BUILD_ONLY_DYNAMIC )
find_package( Vulkan REQUIRED )
vulkan_hpp__setup_test( NAME HandlesMoveExchange LIBRARIES ${Vulkan_LIBRARIES} )
endif()

49
tests/HandlesMoveExchange/HandlesMoveExchange.cpp Normal file
View File

@ -0,0 +1,49 @@
// Copyright(c) 2024, NVIDIA CORPORATION. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#undef VULKAN_HPP_DISPATCH_LOADER_DYNAMIC
#define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
#define VULKAN_HPP_HANDLES_MOVE_EXCHANGE
#include <iostream>
#include <vulkan/vulkan.hpp>
int main( int /*argc*/, char ** /*argv*/ )
{
try
{
vk::Instance instance;
instance = vk::createInstance( {} );
assert( instance != nullptr );
vk::Instance anotherInstance = std::move( instance );
assert( instance == nullptr );
assert( anotherInstance != nullptr );
anotherInstance.destroy();
}
catch ( vk::SystemError const & err )
{
std::cout << "vk::SystemError: " << err.what() << std::endl;
exit( -1 );
}
catch ( ... )
{
std::cout << "unknown error\n";
exit( -1 );
}
return 0;
}

3
vulkan/vulkan.cppm
View File

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

13
vulkan/vulkan.hpp
View File

@ -12,6 +12,7 @@
#include <array> // ArrayWrapperND
#include <string.h> // strnlen
#include <string> // std::string
#include <utility> // std::exchange
#include <vulkan/vulkan.h>
#include <vulkan/vulkan_hpp_macros.hpp>
@ -5889,6 +5890,18 @@ namespace VULKAN_HPP_NAMESPACE
}
#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 )
struct AllocationCallbacks;

809
vulkan/vulkan_handles.hpp
View File

File diff suppressed because it is too large Load Diff

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;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
using VULKAN_HPP_NAMESPACE::exchange;
//==================
//=== BASE TYPEs ===
//==================
@ -1835,7 +1837,6 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_RAII_NAMESPACE::Context;
using VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher;
using VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher;
using VULKAN_HPP_RAII_NAMESPACE::exchange;
using VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher;
//====================

13
vulkan/vulkansc.hpp
View File

@ -12,6 +12,7 @@
#include <array> // ArrayWrapperND
#include <string.h> // strnlen
#include <string> // std::string
#include <utility> // std::exchange
#include <vulkan/vulkan_hpp_macros.hpp>
#include <vulkan/vulkan_sc_core.h>
@ -3151,6 +3152,18 @@ namespace VULKAN_HPP_NAMESPACE
}
#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 )
struct AllocationCallbacks;

513
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( DebugUtilsMessengerEXT const & rhs ) = default;
DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & rhs ) = default;
DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) = default;
DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DebugUtilsMessengerEXT( 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 {}
@ -1148,8 +1162,19 @@ namespace VULKAN_HPP_NAMESPACE
SurfaceKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
SurfaceKHR( SurfaceKHR const & rhs ) = default;
SurfaceKHR & operator=( SurfaceKHR const & rhs ) = default;
SurfaceKHR( SurfaceKHR && rhs ) = default;
SurfaceKHR & operator=( SurfaceKHR && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
SurfaceKHR( 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 {}
@ -1247,8 +1272,19 @@ namespace VULKAN_HPP_NAMESPACE
DisplayKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DisplayKHR( DisplayKHR const & rhs ) = default;
DisplayKHR & operator=( DisplayKHR const & rhs ) = default;
DisplayKHR( DisplayKHR && rhs ) = default;
DisplayKHR & operator=( DisplayKHR && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DisplayKHR( 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 {}
@ -1346,8 +1382,19 @@ namespace VULKAN_HPP_NAMESPACE
SwapchainKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
SwapchainKHR( SwapchainKHR const & rhs ) = default;
SwapchainKHR & operator=( SwapchainKHR const & rhs ) = default;
SwapchainKHR( SwapchainKHR && rhs ) = default;
SwapchainKHR & operator=( SwapchainKHR && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
SwapchainKHR( 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 {}
@ -1445,8 +1492,19 @@ namespace VULKAN_HPP_NAMESPACE
Semaphore() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Semaphore( Semaphore const & rhs ) = default;
Semaphore & operator=( Semaphore const & rhs ) = default;
Semaphore( Semaphore && rhs ) = default;
Semaphore & operator=( Semaphore && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Semaphore( 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 {}
@ -1544,8 +1602,19 @@ namespace VULKAN_HPP_NAMESPACE
Fence() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Fence( Fence const & rhs ) = default;
Fence & operator=( Fence const & rhs ) = default;
Fence( Fence && rhs ) = default;
Fence & operator=( Fence && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Fence( 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 {}
@ -1643,8 +1712,19 @@ namespace VULKAN_HPP_NAMESPACE
QueryPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
QueryPool( QueryPool const & rhs ) = default;
QueryPool & operator=( QueryPool const & rhs ) = default;
QueryPool( QueryPool && rhs ) = default;
QueryPool & operator=( QueryPool && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
QueryPool( 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 {}
@ -1742,8 +1822,19 @@ namespace VULKAN_HPP_NAMESPACE
PipelineLayout() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
PipelineLayout( PipelineLayout const & rhs ) = default;
PipelineLayout & operator=( PipelineLayout const & rhs ) = default;
PipelineLayout( PipelineLayout && rhs ) = default;
PipelineLayout & operator=( PipelineLayout && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
PipelineLayout( 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 {}
@ -1841,8 +1932,19 @@ namespace VULKAN_HPP_NAMESPACE
DescriptorSet() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DescriptorSet( DescriptorSet const & rhs ) = default;
DescriptorSet & operator=( DescriptorSet const & rhs ) = default;
DescriptorSet( DescriptorSet && rhs ) = default;
DescriptorSet & operator=( DescriptorSet && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DescriptorSet( 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 {}
@ -1940,8 +2042,19 @@ namespace VULKAN_HPP_NAMESPACE
Buffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Buffer( Buffer const & rhs ) = default;
Buffer & operator=( Buffer const & rhs ) = default;
Buffer( Buffer && rhs ) = default;
Buffer & operator=( Buffer && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Buffer( 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 {}
@ -2039,8 +2152,19 @@ namespace VULKAN_HPP_NAMESPACE
Pipeline() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Pipeline( Pipeline const & rhs ) = default;
Pipeline & operator=( Pipeline const & rhs ) = default;
Pipeline( Pipeline && rhs ) = default;
Pipeline & operator=( Pipeline && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Pipeline( 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 {}
@ -2138,8 +2262,19 @@ namespace VULKAN_HPP_NAMESPACE
Image() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Image( Image const & rhs ) = default;
Image & operator=( Image const & rhs ) = default;
Image( Image && rhs ) = default;
Image & operator=( Image && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Image( 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 {}
@ -2237,8 +2372,19 @@ namespace VULKAN_HPP_NAMESPACE
Event() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Event( Event const & rhs ) = default;
Event & operator=( Event const & rhs ) = default;
Event( Event && rhs ) = default;
Event & operator=( Event && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Event( 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 {}
@ -2336,8 +2482,19 @@ namespace VULKAN_HPP_NAMESPACE
CommandBuffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
CommandBuffer( CommandBuffer const & rhs ) = default;
CommandBuffer & operator=( CommandBuffer const & rhs ) = default;
CommandBuffer( CommandBuffer && rhs ) = default;
CommandBuffer & operator=( CommandBuffer && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
CommandBuffer( 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 {}
@ -3493,8 +3650,19 @@ namespace VULKAN_HPP_NAMESPACE
DeviceMemory() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DeviceMemory( DeviceMemory const & rhs ) = default;
DeviceMemory & operator=( DeviceMemory const & rhs ) = default;
DeviceMemory( DeviceMemory && rhs ) = default;
DeviceMemory & operator=( DeviceMemory && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DeviceMemory( 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 {}
@ -3517,7 +3685,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceMemory const & ) const = default;
#else
bool operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_deviceMemory == rhs.m_deviceMemory;
}
@ -3592,8 +3760,19 @@ namespace VULKAN_HPP_NAMESPACE
BufferView() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
BufferView( BufferView const & rhs ) = default;
BufferView & operator=( BufferView const & rhs ) = default;
BufferView( BufferView && rhs ) = default;
BufferView & operator=( BufferView && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
BufferView( 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 {}
@ -3691,8 +3870,19 @@ namespace VULKAN_HPP_NAMESPACE
CommandPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
CommandPool( CommandPool const & rhs ) = default;
CommandPool & operator=( CommandPool const & rhs ) = default;
CommandPool( CommandPool && rhs ) = default;
CommandPool & operator=( CommandPool && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
CommandPool( 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 {}
@ -3790,8 +3980,19 @@ namespace VULKAN_HPP_NAMESPACE
PipelineCache() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
PipelineCache( PipelineCache const & rhs ) = default;
PipelineCache & operator=( PipelineCache const & rhs ) = default;
PipelineCache( PipelineCache && rhs ) = default;
PipelineCache & operator=( PipelineCache && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
PipelineCache( 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 {}
@ -3889,8 +4090,19 @@ namespace VULKAN_HPP_NAMESPACE
DescriptorPool() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DescriptorPool( DescriptorPool const & rhs ) = default;
DescriptorPool & operator=( DescriptorPool const & rhs ) = default;
DescriptorPool( DescriptorPool && rhs ) = default;
DescriptorPool & operator=( DescriptorPool && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DescriptorPool( 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 {}
@ -3988,8 +4200,22 @@ namespace VULKAN_HPP_NAMESPACE
DescriptorSetLayout() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DescriptorSetLayout( DescriptorSetLayout const & rhs ) = default;
DescriptorSetLayout & operator=( DescriptorSetLayout const & rhs ) = default;
DescriptorSetLayout( DescriptorSetLayout && rhs ) = default;
DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DescriptorSetLayout( 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 {}
@ -4090,8 +4316,19 @@ namespace VULKAN_HPP_NAMESPACE
Framebuffer() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Framebuffer( Framebuffer const & rhs ) = default;
Framebuffer & operator=( Framebuffer const & rhs ) = default;
Framebuffer( Framebuffer && rhs ) = default;
Framebuffer & operator=( Framebuffer && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Framebuffer( 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 {}
@ -4189,8 +4426,19 @@ namespace VULKAN_HPP_NAMESPACE
ImageView() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
ImageView( ImageView const & rhs ) = default;
ImageView & operator=( ImageView const & rhs ) = default;
ImageView( ImageView && rhs ) = default;
ImageView & operator=( ImageView && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
ImageView( 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 {}
@ -4288,8 +4536,19 @@ namespace VULKAN_HPP_NAMESPACE
PrivateDataSlot() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
PrivateDataSlot( PrivateDataSlot const & rhs ) = default;
PrivateDataSlot & operator=( PrivateDataSlot const & rhs ) = default;
PrivateDataSlot( PrivateDataSlot && rhs ) = default;
PrivateDataSlot & operator=( PrivateDataSlot && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
PrivateDataSlot( 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 {}
@ -4383,8 +4642,19 @@ namespace VULKAN_HPP_NAMESPACE
RenderPass() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
RenderPass( RenderPass const & rhs ) = default;
RenderPass & operator=( RenderPass const & rhs ) = default;
RenderPass( RenderPass && rhs ) = default;
RenderPass & operator=( RenderPass && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
RenderPass( 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 {}
@ -4482,8 +4752,19 @@ namespace VULKAN_HPP_NAMESPACE
Sampler() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Sampler( Sampler const & rhs ) = default;
Sampler & operator=( Sampler const & rhs ) = default;
Sampler( Sampler && rhs ) = default;
Sampler & operator=( Sampler && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Sampler( 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 {}
@ -4581,8 +4862,22 @@ namespace VULKAN_HPP_NAMESPACE
SamplerYcbcrConversion() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
SamplerYcbcrConversion( SamplerYcbcrConversion const & rhs ) = default;
SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & rhs ) = default;
SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) = default;
SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
SamplerYcbcrConversion( 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 {}
@ -4686,8 +4981,22 @@ namespace VULKAN_HPP_NAMESPACE
SemaphoreSciSyncPoolNV() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
SemaphoreSciSyncPoolNV( SemaphoreSciSyncPoolNV const & rhs ) = default;
SemaphoreSciSyncPoolNV & operator=( SemaphoreSciSyncPoolNV const & rhs ) = default;
SemaphoreSciSyncPoolNV( SemaphoreSciSyncPoolNV && rhs ) = default;
SemaphoreSciSyncPoolNV & operator=( SemaphoreSciSyncPoolNV && rhs ) = default;
# if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
SemaphoreSciSyncPoolNV( 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 {}
@ -4783,8 +5092,19 @@ namespace VULKAN_HPP_NAMESPACE
Queue() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Queue( Queue const & rhs ) = default;
Queue & operator=( Queue const & rhs ) = default;
Queue( Queue && rhs ) = default;
Queue & operator=( Queue && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Queue( 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 {}
@ -4984,8 +5304,19 @@ namespace VULKAN_HPP_NAMESPACE
Device() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Device( Device const & rhs ) = default;
Device & operator=( Device const & rhs ) = default;
Device( Device && rhs ) = default;
Device & operator=( Device && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Device( 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 {}
@ -5006,7 +5337,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( Device const & ) const = default;
#else
bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_device == rhs.m_device;
}
@ -7138,8 +7469,19 @@ namespace VULKAN_HPP_NAMESPACE
DisplayModeKHR() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
DisplayModeKHR( DisplayModeKHR const & rhs ) = default;
DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) = default;
DisplayModeKHR( DisplayModeKHR && rhs ) = default;
DisplayModeKHR & operator=( DisplayModeKHR && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
DisplayModeKHR( 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 {}
@ -7162,7 +7504,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DisplayModeKHR const & ) const = default;
#else
bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return m_displayModeKHR == rhs.m_displayModeKHR;
}
@ -7237,8 +7579,19 @@ namespace VULKAN_HPP_NAMESPACE
PhysicalDevice() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
PhysicalDevice( PhysicalDevice const & rhs ) = default;
PhysicalDevice & operator=( PhysicalDevice const & rhs ) = default;
PhysicalDevice( PhysicalDevice && rhs ) = default;
PhysicalDevice & operator=( PhysicalDevice && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
PhysicalDevice( 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 {}
@ -8136,8 +8489,19 @@ namespace VULKAN_HPP_NAMESPACE
Instance() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
Instance( Instance const & rhs ) = default;
Instance & operator=( Instance const & rhs ) = default;
Instance( Instance && rhs ) = default;
Instance & operator=( Instance && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
Instance( 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 {}
@ -8482,8 +8846,19 @@ namespace VULKAN_HPP_NAMESPACE
ShaderModule() VULKAN_HPP_NOEXCEPT{}; // = default - try to workaround a compiler issue
ShaderModule( ShaderModule const & rhs ) = default;
ShaderModule & operator=( ShaderModule const & rhs ) = default;
ShaderModule( ShaderModule && rhs ) = default;
ShaderModule & operator=( ShaderModule && rhs ) = default;
#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
ShaderModule( 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 {}

326
vulkan/vulkansc_raii.hpp
View File

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