mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-09-20 05:52:16 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #1204 from asuessenbach/swap

Browse Source 
Introduce member function swap() for raii-classes.
This commit is contained in:
Andreas Süßenbach 2022-02-15 08:25:33 +01:00 committed by GitHub
commit e367563e7c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 462 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
VulkanHppGenerator.cpp
View File

@ -3142,7 +3142,7 @@ std::string VulkanHppGenerator::generateCommandDefinitions( std::string const &
{
std::string toEncloseString = stripPrefix( handle, "Vk" ) + "::free";
std::string enclosedString = "( " + toEncloseString + " )";
pos = destroyCommandString.find( toEncloseString );
pos = destroyCommandString.find( toEncloseString );
while ( pos != std::string::npos )
{
destroyCommandString.replace( pos, toEncloseString.length(), enclosedString );
@ -6878,8 +6878,11 @@ std::string VulkanHppGenerator::generateRAIIHandle( std::pair<std::string, Handl
? std::make_pair( "", "" )
: generateRAIIHandleDestructor( handle.first, handle.second.destructorIt, enter );
auto [getConstructorSuccessCode, memberVariables, moveConstructorInitializerList, moveAssignmentInstructions] =
generateRAIIHandleDetails( handle, destructorCall );
auto [getConstructorSuccessCode,
memberVariables,
moveConstructorInitializerList,
moveAssignmentInstructions,
swapMembers] = generateRAIIHandleDetails( handle, destructorCall );
std::string declarations = generateRAIIHandleCommandDeclarations( handle, specialFunctions );
@ -6963,6 +6966,12 @@ ${getParent}
VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
return ${getDispatcherReturn}m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::${handleType} & rhs )
{
${swapMembers}
}
${memberFunctionsDeclarations}
private:
@ -6987,7 +6996,8 @@ ${leave})";
{ "moveAssignmentInstructions", moveAssignmentInstructions },
{ "moveConstructorInitializerList", moveConstructorInitializerList },
{ "objTypeEnum", objTypeEnum },
{ "singularConstructors", singularConstructors } } );
{ "singularConstructors", singularConstructors },
{ "swapMembers", swapMembers } } );
if ( !arrayConstructors.empty() )
{
@ -10521,14 +10531,22 @@ std::string VulkanHppGenerator::generateRAIIHandleContext( std::pair<std::string
return *this;
}
${memberFunctionDeclarations}
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher const * getDispatcher() const
{
VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
return &*m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context & rhs )
{
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
std::swap( m_dynamicLoader, rhs.m_dynamicLoader );
#endif
m_dispatcher.swap( rhs.m_dispatcher );
}
${memberFunctionDeclarations}
private:
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
VULKAN_HPP_NAMESPACE::DynamicLoader m_dynamicLoader;
@ -10641,7 +10659,7 @@ std::string VulkanHppGenerator::generateRAIIHandleDestructorCallArguments(
return arguments;
}
std::tuple<std::string, std::string, std::string, std::string>
std::tuple<std::string, std::string, std::string, std::string, std::string>
VulkanHppGenerator::generateRAIIHandleDetails( std::pair<std::string, HandleData> const & handle,
std::string const & destructorCall ) const
{
@ -10662,37 +10680,25 @@ std::tuple<std::string, std::string, std::string, std::string>
std::string handleType = stripPrefix( handle.first, "Vk" );
std::string handleName = generateRAIIHandleConstructorParamName( handle.first, handle.second.destructorIt );
std::string moveConstructorInitializerList, moveAssignmentInstructions, memberVariables;
std::string moveConstructorInitializerList, moveAssignmentInstructions, memberVariables, swapMembers;
if ( handle.second.destructorIt != m_commands.end() )
{
moveAssignmentInstructions = " if ( m_" + handleName +
" )\n"
" {\n"
" getDispatcher()->" +
destructorCall +
";\n"
" }";
moveAssignmentInstructions = " if ( m_" + handleName + " )\n";
moveAssignmentInstructions += " {\n";
moveAssignmentInstructions += " getDispatcher()->" + destructorCall + ";\n";
moveAssignmentInstructions += " }";
for ( auto const & destructorParam : handle.second.destructorIt->second.params )
{
std::string memberName, memberType;
if ( destructorParam.type.type == "Vk" + parentType )
{
moveConstructorInitializerList = "m_" + parentName +
"( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
parentName + ", {} ) ), ";
moveAssignmentInstructions += "\n m_" + parentName +
" = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
parentName + ", {} );";
memberVariables = "\n VULKAN_HPP_NAMESPACE::" + parentType + " m_" + parentName + " = {};";
memberName = parentName;
memberType = "VULKAN_HPP_NAMESPACE::" + parentType;
}
else if ( destructorParam.type.type == handle.first )
{
moveConstructorInitializerList += "m_" + handleName +
"( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
handleName + ", {} ) ), ";
moveAssignmentInstructions += "\n m_" + handleName +
" = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
handleName + ", {} );";
memberVariables += "\n VULKAN_HPP_NAMESPACE::" + handleType + " m_" + handleName + " = {};";
memberName = handleName;
memberType = "VULKAN_HPP_NAMESPACE::" + handleType;
}
else if ( std::find_if( handle.second.destructorIt->second.params.begin(),
handle.second.destructorIt->second.params.end(),
@ -10704,13 +10710,19 @@ std::tuple<std::string, std::string, std::string, std::string>
{
name = startLowerCase( stripPrefix( name, "p" ) );
}
memberVariables += "\n " + destructorParam.type.compose( "VULKAN_HPP_NAMESPACE" ) + " m_" + name + " = " +
( destructorParam.type.postfix.empty() ? "{}" : "nullptr" ) + ";";
moveConstructorInitializerList +=
"m_" + name + "( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + name + ", {} ) ), ";
moveAssignmentInstructions += "\n m_" + name +
" = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + name +
", {} );";
memberName = name;
memberType = destructorParam.type.compose( "VULKAN_HPP_NAMESPACE" );
}
if ( !memberName.empty() )
{
moveConstructorInitializerList += "m_" + memberName +
"( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
memberName + ", {} ) ), ";
moveAssignmentInstructions += "\n m_" + memberName +
" = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
memberName + ", {} );";
memberVariables += "\n " + memberType + " m_" + memberName + " = {};";
swapMembers += "\n std::swap( m_" + memberName + ", rhs.m_" + memberName + " );";
}
}
}
@ -10734,6 +10746,7 @@ std::tuple<std::string, std::string, std::string, std::string>
" = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + frontName +
", {} );";
memberVariables = "\n VULKAN_HPP_NAMESPACE::" + stripPrefix( frontType, "Vk" ) + " m_" + frontName + " = {};";
swapMembers = "\n std::swap( m_" + frontName + ", rhs.m_" + frontName + " );";
}
moveConstructorInitializerList += "m_" + handleName +
"( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" +
@ -10742,11 +10755,13 @@ std::tuple<std::string, std::string, std::string, std::string>
" = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_" + handleName +
", {} );";
memberVariables += "\n VULKAN_HPP_NAMESPACE::" + handleType + " m_" + handleName + " = {};";
swapMembers += "\n std::swap( m_" + handleName + ", rhs.m_" + handleName + " );";
}
if ( multiSuccessCodeContructor )
{
memberVariables += "\n VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode;";
swapMembers += "\n std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode );";
}
if ( handle.first == "VkInstance" )
@ -10769,6 +10784,7 @@ std::tuple<std::string, std::string, std::string, std::string>
memberVariables +=
"\n VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;";
}
swapMembers += "\n std::swap( m_dispatcher, rhs.m_dispatcher );";
if ( ( handle.first == "VkInstance" ) || ( handle.first == "VkDevice" ) )
{
@ -10783,8 +10799,11 @@ std::tuple<std::string, std::string, std::string, std::string>
"\n m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );";
}
return std::make_tuple(
getConstructorSuccessCode, memberVariables, moveConstructorInitializerList, moveAssignmentInstructions );
return std::make_tuple( getConstructorSuccessCode,
memberVariables,
moveConstructorInitializerList,
moveAssignmentInstructions,
swapMembers );
}
std::string VulkanHppGenerator::generateRAIIHandleForwardDeclarations( std::vector<RequireData> const & requireData,

2
VulkanHppGenerator.hpp
View File

@ -1123,7 +1123,7 @@ private:
std::string
generateRAIIHandleDestructorCallArguments( std::string const & handleType,
std::map<std::string, CommandData>::const_iterator destructorIt ) const;
std::tuple<std::string, std::string, std::string, std::string>
std::tuple<std::string, std::string, std::string, std::string, std::string>
generateRAIIHandleDetails( std::pair<std::string, HandleData> const & handle,
std::string const & destructorCall ) const;
std::string generateRAIIHandleForwardDeclarations( std::vector<RequireData> const & requireData,

448
vulkan/vulkan_raii.hpp
View File

@ -2517,6 +2517,20 @@ namespace VULKAN_HPP_NAMESPACE
return *this;
}
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher const * getDispatcher() const
{
VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
return &*m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context & rhs )
{
# if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
std::swap( m_dynamicLoader, rhs.m_dynamicLoader );
# endif
m_dispatcher.swap( rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Instance createInstance(
@ -2532,12 +2546,6 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD uint32_t enumerateInstanceVersion() const;
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher const * getDispatcher() const
{
VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
return &*m_dispatcher;
}
private:
# if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
VULKAN_HPP_NAMESPACE::DynamicLoader m_dynamicLoader;
@ -2629,6 +2637,13 @@ namespace VULKAN_HPP_NAMESPACE
return &*m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance & rhs )
{
std::swap( m_instance, rhs.m_instance );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> enumeratePhysicalDevices() const;
@ -2788,7 +2803,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Instance m_instance = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher> m_dispatcher;
};
@ -2838,6 +2853,12 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice & rhs )
{
std::swap( m_physicalDevice, rhs.m_physicalDevice );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures getFeatures() const VULKAN_HPP_NOEXCEPT;
@ -3315,6 +3336,13 @@ namespace VULKAN_HPP_NAMESPACE
return &*m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT;
@ -4033,7 +4061,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher> m_dispatcher;
};
@ -4137,10 +4165,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_accelerationStructure, rhs.m_accelerationStructure );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::AccelerationStructureKHR m_accelerationStructure = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -4244,6 +4280,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_accelerationStructure, rhs.m_accelerationStructure );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_NV_ray_tracing ===
template <typename DataType>
@ -4255,7 +4299,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::AccelerationStructureNV m_accelerationStructure = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -4352,6 +4396,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Buffer & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_buffer, rhs.m_buffer );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const;
@ -4361,7 +4413,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::Buffer m_buffer = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -4464,6 +4516,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_collection, rhs.m_collection );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_FUCHSIA_buffer_collection ===
void setImageConstraints( const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const;
@ -4476,7 +4536,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA m_collection = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
# endif /*VK_USE_PLATFORM_FUCHSIA*/
@ -4574,10 +4634,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferView & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_bufferView, rhs.m_bufferView );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::BufferView m_bufferView = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -4674,6 +4742,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandPool & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_commandPool, rhs.m_commandPool );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
void reset( VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
@ -4691,7 +4767,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -4772,6 +4848,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_commandPool, rhs.m_commandPool );
std::swap( m_commandBuffer, rhs.m_commandBuffer );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
void begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo ) const;
@ -5709,10 +5793,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_function, rhs.m_function );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::CuFunctionNVX m_function = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -5809,10 +5901,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_module, rhs.m_module );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::CuModuleNVX m_module = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -5914,10 +6014,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT & rhs )
{
std::swap( m_instance, rhs.m_instance );
std::swap( m_callback, rhs.m_callback );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Instance m_instance = {};
VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT m_callback = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
};
@ -6019,10 +6127,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT & rhs )
{
std::swap( m_instance, rhs.m_instance );
std::swap( m_messenger, rhs.m_messenger );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Instance m_instance = {};
VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT m_messenger = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
};
@ -6122,6 +6238,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_operation, rhs.m_operation );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_KHR_deferred_host_operations ===
VULKAN_HPP_NODISCARD uint32_t getMaxConcurrency() const VULKAN_HPP_NOEXCEPT;
@ -6133,7 +6257,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::DeferredOperationKHR m_operation = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -6233,6 +6357,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorPool & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_descriptorPool, rhs.m_descriptorPool );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
void reset( VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const
@ -6241,7 +6373,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -6322,6 +6454,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_descriptorPool, rhs.m_descriptorPool );
std::swap( m_descriptorSet, rhs.m_descriptorSet );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_1 ===
template <typename DataType>
@ -6474,10 +6614,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_descriptorSetLayout, rhs.m_descriptorSetLayout );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::DescriptorSetLayout m_descriptorSetLayout = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -6581,10 +6729,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_descriptorUpdateTemplate, rhs.m_descriptorUpdateTemplate );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -6683,6 +6839,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceMemory & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_memory, rhs.m_memory );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
VULKAN_HPP_NODISCARD void *
@ -6708,7 +6872,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::DeviceMemory m_memory = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -6830,6 +6994,13 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR & rhs )
{
std::swap( m_physicalDevice, rhs.m_physicalDevice );
std::swap( m_display, rhs.m_display );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_KHR_display ===
VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> getModeProperties() const;
@ -6968,6 +7139,13 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR & rhs )
{
std::swap( m_physicalDevice, rhs.m_physicalDevice );
std::swap( m_displayModeKHR, rhs.m_displayModeKHR );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_KHR_display ===
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR
@ -7072,6 +7250,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Event & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_event, rhs.m_event );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const;
@ -7083,7 +7269,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::Event m_event = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -7220,6 +7406,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_fence, rhs.m_fence );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const;
@ -7227,7 +7421,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::Fence m_fence = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -7324,10 +7518,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Framebuffer & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_framebuffer, rhs.m_framebuffer );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::Framebuffer m_framebuffer = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -7424,6 +7626,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Image & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_image, rhs.m_image );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const;
@ -7444,7 +7654,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::Image m_image = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -7541,6 +7751,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ImageView & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_imageView, rhs.m_imageView );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_NVX_image_view_handle ===
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX getAddressNVX() const;
@ -7548,7 +7766,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::ImageView m_imageView = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -7652,10 +7870,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_indirectCommandsLayout, rhs.m_indirectCommandsLayout );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV m_indirectCommandsLayout = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -7742,6 +7968,13 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_configuration, rhs.m_configuration );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL m_configuration = {};
@ -7844,6 +8077,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_pipelineCache, rhs.m_pipelineCache );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const;
@ -7853,7 +8094,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::PipelineCache m_pipelineCache = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -8043,6 +8284,15 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_pipeline, rhs.m_pipeline );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_AMD_shader_info ===
VULKAN_HPP_NODISCARD std::vector<uint8_t>
@ -8083,7 +8333,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::Pipeline m_pipeline = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode;
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -8331,10 +8581,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineLayout & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_pipelineLayout, rhs.m_pipelineLayout );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::PipelineLayout m_pipelineLayout = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -8434,10 +8692,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_privateDataSlot, rhs.m_privateDataSlot );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::PrivateDataSlot m_privateDataSlot = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -8534,6 +8800,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::QueryPool & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_queryPool, rhs.m_queryPool );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
template <typename DataType>
@ -8562,7 +8836,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::QueryPool m_queryPool = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -8629,6 +8903,12 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue & rhs )
{
std::swap( m_queue, rhs.m_queue );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
void submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
@ -8792,6 +9072,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_renderPass, rhs.m_renderPass );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_0 ===
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT;
@ -8804,7 +9092,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::RenderPass m_renderPass = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -8901,10 +9189,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Sampler & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_sampler, rhs.m_sampler );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::Sampler m_sampler = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -9006,10 +9302,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_ycbcrConversion, rhs.m_ycbcrConversion );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion m_ycbcrConversion = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -9106,6 +9410,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Semaphore & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_semaphore, rhs.m_semaphore );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_VERSION_1_2 ===
VULKAN_HPP_NODISCARD uint64_t getCounterValue() const;
@ -9117,7 +9429,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::Semaphore m_semaphore = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -9217,10 +9529,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderModule & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_shaderModule, rhs.m_shaderModule );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::ShaderModule m_shaderModule = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -9610,10 +9930,18 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR & rhs )
{
std::swap( m_instance, rhs.m_instance );
std::swap( m_surface, rhs.m_surface );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
private:
VULKAN_HPP_NAMESPACE::Instance m_instance = {};
VULKAN_HPP_NAMESPACE::SurfaceKHR m_surface = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
};
@ -9713,6 +10041,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_swapchain, rhs.m_swapchain );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_KHR_swapchain ===
VULKAN_HPP_NODISCARD std::vector<VkImage> getImages() const;
@ -9756,7 +10092,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::SwapchainKHR m_swapchain = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -9897,6 +10233,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_validationCache, rhs.m_validationCache );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_EXT_validation_cache ===
void merge( ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches ) const;
@ -9906,7 +10250,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::ValidationCacheEXT m_validationCache = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
@ -10007,6 +10351,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_videoSession, rhs.m_videoSession );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_KHR_video_queue ===
VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR> getMemoryRequirements() const;
@ -10017,7 +10369,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::VideoSessionKHR m_videoSession = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
@ -10123,6 +10475,14 @@ namespace VULKAN_HPP_NAMESPACE
return m_dispatcher;
}
void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR & rhs )
{
std::swap( m_device, rhs.m_device );
std::swap( m_videoSessionParameters, rhs.m_videoSessionParameters );
std::swap( m_allocator, rhs.m_allocator );
std::swap( m_dispatcher, rhs.m_dispatcher );
}
//=== VK_KHR_video_queue ===
void update( const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo ) const;
@ -10130,7 +10490,7 @@ namespace VULKAN_HPP_NAMESPACE
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR m_videoSessionParameters = {};
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr;
const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/