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

Move all the management helper classes for SharedHandles and UniqueHandles into namespace detail. (#1984)

Browse Source
This commit is contained in:
Andreas Süßenbach 2024-10-30 08:14:48 +01:00 committed by GitHub
parent ed3cf7ac51
commit 6e5489fcd9
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
13 changed files with 1018 additions and 974 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
VulkanHppGenerator.cpp
View File

@ -475,12 +475,19 @@ namespace VULKAN_HPP_NAMESPACE
${DispatchLoaderStatic}
}
${Exchange}
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
${ObjectDestroy}
${ObjectFree}
${ObjectRelease}
${PoolFree}
struct AllocationCallbacks;
namespace detail
{
${ObjectDestroy}
${ObjectFree}
${ObjectRelease}
${PoolFree}
}
#endif // !VULKAN_HPP_NO_SMART_HANDLE
${baseTypes}
template <typename Type, Type value = Type{}>
@ -698,11 +705,14 @@ void VulkanHppGenerator::generateSharedHppFile() const
namespace VULKAN_HPP_NAMESPACE
{
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
${sharedHandle}
${sharedDestroy}
${sharedHandles}
${sharedHandleSpecializations}
${sharedHandlesNoDestroy}
${sharedHandle}
namespace detail
{
${sharedDestroy}
}
${sharedHandles}
${sharedHandleSpecializations}
${sharedHandlesNoDestroy}
#endif // !VULKAN_HPP_NO_SMART_HANDLE
} // namespace VULKAN_HPP_NAMESPACE
#endif // VULKAN_SHARED_HPP
@ -5917,10 +5927,10 @@ std::string VulkanHppGenerator::generateCppModuleUsings() const
auto const usingTemplate = std::string{ R"( using VULKAN_HPP_NAMESPACE::${className};
)" };
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 const hardCodedEnhancedModeTypes = std::array{ "ArrayProxy", "ArrayProxyNoTemporaries", "StridedArrayProxy", "Optional", "StructureChain" };
auto const hardCodedSmartHandleHelperTypes = std::array{ "ObjectDestroy", "ObjectFree", "ObjectRelease", "PoolFree",
"ObjectDestroyShared", "ObjectFreeShared", "ObjectReleaseShared", "PoolFreeShared" };
auto const hardCodedFunctions = std::array{ "exchange" };
auto usings = std::string{ R"( //=====================================
//=== HARDCODED TYPEs AND FUNCTIONs ===
@ -5959,14 +5969,20 @@ std::string VulkanHppGenerator::generateCppModuleUsings() const
const auto [enterEnhancedMode, leaveEnhancedMode] = generateProtection( "VULKAN_HPP_DISABLE_ENHANCED_MODE", false );
usings += "\n" + enterEnhancedMode + enhancedModeUsings + leaveEnhancedMode + "\n";
auto noSmartHandleUsings = std::string{};
for ( auto const & className : hardCodedSmartHandleTypes )
std::string smartHandleUsings = " namespace detail\n {\n";
for ( auto const & helperType : hardCodedSmartHandleHelperTypes )
{
noSmartHandleUsings += replaceWithMap( usingTemplate, { { "className", std::string{ className } } } );
smartHandleUsings += " using VULKAN_HPP_NAMESPACE::detail::"s + helperType + ";\n";
}
smartHandleUsings += R"( }
using VULKAN_HPP_NAMESPACE::SharedHandle;
using VULKAN_HPP_NAMESPACE::UniqueHandle;
)";
// likewise for the smart-handle usings
const auto [enterNoSmartHandle, leaveNoSmartHandle] = generateProtection( "VULKAN_HPP_NO_SMART_HANDLE", false );
usings += "\n" + enterNoSmartHandle + noSmartHandleUsings + leaveNoSmartHandle + "\n";
usings += "\n" + enterNoSmartHandle + smartHandleUsings + leaveNoSmartHandle + "\n";
for ( auto const & functionName : hardCodedFunctions )
{
@ -6556,7 +6572,7 @@ std::string VulkanHppGenerator::generateDataPreparation( CommandData const &
vectorParamIt = vectorParams.find( returnParams[0] );
if ( vectorParamIt != vectorParams.end() && vectorParamIt->second.byStructure )
{
deleterDefinition = "ObjectDestroy<" + className + ", Dispatch> deleter( *this, allocator, d )";
deleterDefinition = "detail::ObjectDestroy<" + className + ", Dispatch> deleter( *this, allocator, d )";
auto structIt = m_structs.find( commandData.params[returnParams[0]].type.type );
assert( structIt != m_structs.end() );
vectorName = startLowerCase( stripPrefix( structIt->second.members.back().name, "p" ) );
@ -6567,7 +6583,7 @@ std::string VulkanHppGenerator::generateDataPreparation( CommandData const &
std::vector<std::string> lenParts = tokenize( commandData.params[returnParams[0]].lenExpression, "->" );
switch ( lenParts.size() )
{
case 1: deleterDefinition = "ObjectDestroy<" + className + ", Dispatch> deleter( *this, allocator, d )"; break;
case 1: deleterDefinition = "detail::ObjectDestroy<" + className + ", Dispatch> deleter( *this, allocator, d )"; break;
case 2:
{
auto vpiIt = vectorParams.find( returnParams[0] );
@ -6577,7 +6593,7 @@ std::string VulkanHppGenerator::generateDataPreparation( CommandData const &
assert( !poolType.empty() );
poolType = stripPrefix( poolType, "Vk" );
poolName = startLowerCase( stripPrefix( lenParts[0], "p" ) ) + "." + poolName;
deleterDefinition = "PoolFree<" + className + ", " + poolType + ", Dispatch> deleter( *this, " + poolName + ", d )";
deleterDefinition = "detail::PoolFree<" + className + ", " + poolType + ", Dispatch> deleter( *this, " + poolName + ", d )";
}
break;
default: assert( false ); break;
@ -8566,7 +8582,7 @@ std::string VulkanHppGenerator::generateObjectDeleter( std::string const & comma
if ( ( commandName == "vkAcquirePerformanceConfigurationINTEL" ) || ( commandName == "vkGetRandROutputDisplayEXT" ) ||
( commandName == "vkGetWinrtDisplayNV" ) || ( commandName == "vkGetDrmDisplayEXT" ) )
{
objectDeleter = "ObjectRelease";
objectDeleter = "detail::ObjectRelease";
}
else
{
@ -8575,18 +8591,18 @@ std::string VulkanHppGenerator::generateObjectDeleter( std::string const & comma
}
else if ( commandName.find( "Allocate" ) != std::string::npos )
{
objectDeleter = "ObjectFree";
objectDeleter = "detail::ObjectFree";
allocator = "allocator, ";
}
else
{
assert( ( commandName.find( "Create" ) != std::string::npos ) || ( commandName.find( "Register" ) != std::string::npos ) );
objectDeleter = "ObjectDestroy";
objectDeleter = "detail::ObjectDestroy";
allocator = "allocator, ";
}
std::string className = initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "";
std::string parentName = ( className.empty() || ( commandData.params[returnParam].type.type == "VkDevice" ) ) ? "NoParent" : className;
return objectDeleter + "<" + parentName + ", Dispatch>( " + ( ( parentName == "NoParent" ) ? "" : "*this, " ) + allocator + "d )";
std::string parentName = ( className.empty() || ( commandData.params[returnParam].type.type == "VkDevice" ) ) ? "detail::NoParent" : className;
return objectDeleter + "<" + parentName + ", Dispatch>( " + ( ( parentName == "detail::NoParent" ) ? "" : "*this, " ) + allocator + "d )";
}
std::string VulkanHppGenerator::generateObjectTypeToDebugReportObjectType() const
@ -12542,18 +12558,19 @@ std::string VulkanHppGenerator::generateUniqueHandle( std::pair<std::string, Han
class UniqueHandleTraits<${type}, Dispatch>
{
public:
using deleter = ${deleterType}${deleterAction}<${deleterParent}${deleterPool}, Dispatch>;
using deleter = detail::${deleterType}${deleterAction}<${deleterParent}${deleterPool}, Dispatch>;
};
using Unique${type} = UniqueHandle<${type}, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
${aliasHandle})";
return replaceWithMap( uniqueHandleTemplate,
{ { "aliasHandle", aliasHandle },
{ "deleterAction", ( handleData.second.deleteCommand.substr( 2, 4 ) == "Free" ) ? "Free" : "Destroy" },
{ "deleterParent", handleData.second.destructorType.empty() ? "NoParent" : stripPrefix( handleData.second.destructorType, "Vk" ) },
{ "deleterPool", handleData.second.deletePool.empty() ? "" : ", " + stripPrefix( handleData.second.deletePool, "Vk" ) },
{ "deleterType", handleData.second.deletePool.empty() ? "Object" : "Pool" },
{ "type", type } } );
return replaceWithMap(
uniqueHandleTemplate,
{ { "aliasHandle", aliasHandle },
{ "deleterAction", ( handleData.second.deleteCommand.substr( 2, 4 ) == "Free" ) ? "Free" : "Destroy" },
{ "deleterParent", handleData.second.destructorType.empty() ? "detail::NoParent" : stripPrefix( handleData.second.destructorType, "Vk" ) },
{ "deleterPool", handleData.second.deletePool.empty() ? "" : ", " + stripPrefix( handleData.second.deletePool, "Vk" ) },
{ "deleterType", handleData.second.deletePool.empty() ? "Object" : "Pool" },
{ "type", type } } );
}
return "";
}
@ -12619,7 +12636,7 @@ std::string VulkanHppGenerator::generateSharedHandle( std::pair<std::string, Han
{
public:
using DestructorType = ${destructor};
using deleter = ${deleterType}${deleterAction}Shared<${type}${deleterPool}>;
using deleter = detail::${deleterType}${deleterAction}Shared<${type}${deleterPool}>;
};
using Shared${type} = SharedHandle<${type}>;
${aliasHandle})";

20
snippets/ObjectDestroy.hpp
View File

@ -1,5 +1,3 @@
struct AllocationCallbacks;
template <typename OwnerType, typename Dispatch>
class ObjectDestroy
{
@ -7,7 +5,7 @@
ObjectDestroy() = default;
ObjectDestroy( OwnerType owner,
Optional<const AllocationCallbacks> allocationCallbacks
Optional<const vk::AllocationCallbacks> allocationCallbacks
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
@ -16,7 +14,7 @@
{}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT { return m_owner; }
Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT { return m_allocationCallbacks; }
Optional<const vk::AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT { return m_allocationCallbacks; }
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT { return *m_dispatch; }
protected:
@ -28,9 +26,9 @@
}
private:
OwnerType m_owner = {};
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
OwnerType m_owner = {};
Optional<const vk::AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
class NoParent;
@ -41,13 +39,13 @@
public:
ObjectDestroy() = default;
ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks,
ObjectDestroy( Optional<const vk::AllocationCallbacks> allocationCallbacks,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{}
Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT { return m_allocationCallbacks; }
Optional<const vk::AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT { return m_allocationCallbacks; }
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT { return *m_dispatch; }
protected:
@ -59,6 +57,6 @@
}
private:
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
Optional<const vk::AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};

3
snippets/SharedDestroy.hpp
View File

@ -1,7 +1,4 @@
template <typename HandleType>
class SharedHandleTraits;
// Silence the function cast warnings.
#if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
# pragma GCC diagnostic push

20
vulkan/vulkan.cppm
View File

@ -59,14 +59,18 @@ export namespace VULKAN_HPP_NAMESPACE
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
using VULKAN_HPP_NAMESPACE::ObjectDestroy;
using VULKAN_HPP_NAMESPACE::ObjectDestroyShared;
using VULKAN_HPP_NAMESPACE::ObjectFree;
using VULKAN_HPP_NAMESPACE::ObjectFreeShared;
using VULKAN_HPP_NAMESPACE::ObjectRelease;
using VULKAN_HPP_NAMESPACE::ObjectReleaseShared;
using VULKAN_HPP_NAMESPACE::PoolFree;
using VULKAN_HPP_NAMESPACE::PoolFreeShared;
namespace detail
{
using VULKAN_HPP_NAMESPACE::detail::ObjectDestroy;
using VULKAN_HPP_NAMESPACE::detail::ObjectDestroyShared;
using VULKAN_HPP_NAMESPACE::detail::ObjectFree;
using VULKAN_HPP_NAMESPACE::detail::ObjectFreeShared;
using VULKAN_HPP_NAMESPACE::detail::ObjectRelease;
using VULKAN_HPP_NAMESPACE::detail::ObjectReleaseShared;
using VULKAN_HPP_NAMESPACE::detail::PoolFree;
using VULKAN_HPP_NAMESPACE::detail::PoolFreeShared;
} // namespace detail
using VULKAN_HPP_NAMESPACE::SharedHandle;
using VULKAN_HPP_NAMESPACE::UniqueHandle;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/

373
vulkan/vulkan.hpp
View File

@ -6056,208 +6056,211 @@ namespace VULKAN_HPP_NAMESPACE
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
struct AllocationCallbacks;
template <typename OwnerType, typename Dispatch>
class ObjectDestroy
namespace detail
{
public:
ObjectDestroy() = default;
ObjectDestroy( OwnerType owner,
Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
template <typename OwnerType, typename Dispatch>
class ObjectDestroy
{
}
public:
ObjectDestroy() = default;
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
ObjectDestroy( OwnerType owner,
Optional<const vk::AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
Optional<const vk::AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
}
private:
OwnerType m_owner = {};
Optional<const vk::AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
class NoParent;
template <typename Dispatch>
class ObjectDestroy<NoParent, Dispatch>
{
return m_owner;
}
public:
ObjectDestroy() = default;
Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
ObjectDestroy( Optional<const vk::AllocationCallbacks> allocationCallbacks,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{
}
Optional<const vk::AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_dispatch );
t.destroy( m_allocationCallbacks, *m_dispatch );
}
private:
Optional<const vk::AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename Dispatch>
class ObjectFree
{
return m_allocationCallbacks;
}
public:
ObjectFree() = default;
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
ObjectFree( OwnerType owner,
Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
( m_owner.free )( t, m_allocationCallbacks, *m_dispatch );
}
private:
OwnerType m_owner = {};
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename Dispatch>
class ObjectRelease
{
return *m_dispatch;
}
public:
ObjectRelease() = default;
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
ObjectRelease( OwnerType owner, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
m_owner.release( t, *m_dispatch );
}
private:
OwnerType m_owner = {};
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename PoolType, typename Dispatch>
class PoolFree
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
}
public:
PoolFree() = default;
private:
OwnerType m_owner = {};
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
PoolFree( OwnerType owner, PoolType pool, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_pool( pool )
, m_dispatch( &dispatch )
{
}
class NoParent;
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
template <typename Dispatch>
class ObjectDestroy<NoParent, Dispatch>
{
public:
ObjectDestroy() = default;
PoolType getPool() const VULKAN_HPP_NOEXCEPT
{
return m_pool;
}
ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
( m_owner.free )( m_pool, t, *m_dispatch );
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_dispatch );
t.destroy( m_allocationCallbacks, *m_dispatch );
}
private:
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename Dispatch>
class ObjectFree
{
public:
ObjectFree() = default;
ObjectFree( OwnerType owner,
Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
( m_owner.free )( t, m_allocationCallbacks, *m_dispatch );
}
private:
OwnerType m_owner = {};
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename Dispatch>
class ObjectRelease
{
public:
ObjectRelease() = default;
ObjectRelease( OwnerType owner, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
m_owner.release( t, *m_dispatch );
}
private:
OwnerType m_owner = {};
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename PoolType, typename Dispatch>
class PoolFree
{
public:
PoolFree() = default;
PoolFree( OwnerType owner, PoolType pool, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_pool( pool )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
PoolType getPool() const VULKAN_HPP_NOEXCEPT
{
return m_pool;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
( m_owner.free )( m_pool, t, *m_dispatch );
}
private:
OwnerType m_owner = OwnerType();
PoolType m_pool = PoolType();
Dispatch const * m_dispatch = nullptr;
};
private:
OwnerType m_owner = OwnerType();
PoolType m_pool = PoolType();
Dispatch const * m_dispatch = nullptr;
};
} // namespace detail
#endif // !VULKAN_HPP_NO_SMART_HANDLE
//==================

214
vulkan/vulkan_funcs.hpp
View File

@ -70,7 +70,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::createInstanceUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>( instance, ObjectDestroy<NoParent, Dispatch>( allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>( instance, detail::ObjectDestroy<detail::NoParent, Dispatch>( allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -490,7 +490,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDeviceUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>( device, ObjectDestroy<NoParent, Dispatch>( allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>( device, detail::ObjectDestroy<detail::NoParent, Dispatch>( allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -998,7 +998,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemoryUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>( memory, ObjectFree<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>( memory, detail::ObjectFree<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -1580,7 +1580,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFenceUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -1779,7 +1779,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphoreUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>( semaphore, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>( semaphore, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -1891,7 +1891,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createEventUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>( event, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>( event, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -2076,7 +2076,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPoolUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>( queryPool, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>( queryPool, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -2274,7 +2274,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>( buffer, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>( buffer, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -2388,7 +2388,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferViewUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>( view, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>( view, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -2500,7 +2500,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>( image, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>( image, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -2647,7 +2647,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageViewUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>( view, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>( view, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -2763,7 +2763,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModuleUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>( shaderModule, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>( shaderModule, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -2879,7 +2879,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCacheUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>( pipelineCache, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>( pipelineCache, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3183,7 +3183,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipeline : pipelines )
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
@ -3220,7 +3220,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipeline : pipelines )
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
@ -3253,7 +3253,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3391,7 +3391,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipeline : pipelines )
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
@ -3428,7 +3428,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipeline : pipelines )
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
@ -3461,7 +3461,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3577,7 +3577,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayoutUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>( pipelineLayout, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>( pipelineLayout, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3689,7 +3689,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>( sampler, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>( sampler, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3803,7 +3803,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayoutUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>( setLayout, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>( setLayout, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3923,7 +3923,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPoolUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>( descriptorPool, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>( descriptorPool, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -4080,7 +4080,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets;
uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount );
PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
detail::PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
for ( auto const & descriptorSet : descriptorSets )
{
uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSet, deleter ) );
@ -4110,7 +4110,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets( descriptorSetAllocator );
uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount );
PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
detail::PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
for ( auto const & descriptorSet : descriptorSets )
{
uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSet, deleter ) );
@ -4270,7 +4270,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebufferUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>( framebuffer, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>( framebuffer, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -4386,7 +4386,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPassUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( renderPass, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( renderPass, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -4528,7 +4528,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPoolUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>( commandPool, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>( commandPool, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -4688,7 +4688,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers;
uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount );
PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d );
detail::PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d );
for ( auto const & commandBuffer : commandBuffers )
{
uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffer, deleter ) );
@ -4718,7 +4718,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers( commandBufferAllocator );
uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount );
PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d );
detail::PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d );
for ( auto const & commandBuffer : commandBuffers )
{
uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffer, deleter ) );
@ -6787,7 +6787,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>( ycbcrConversion, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>( ycbcrConversion, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -6913,7 +6914,7 @@ namespace VULKAN_HPP_NAMESPACE
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result,
UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>(
descriptorUpdateTemplate, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
descriptorUpdateTemplate, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -7253,7 +7254,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2Unique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( renderPass, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( renderPass, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -7647,7 +7648,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>( privateDataSlot, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>( privateDataSlot, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -8794,7 +8796,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>( swapchain, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>( swapchain, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -9578,7 +9580,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>( mode, ObjectDestroy<PhysicalDevice, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>( mode, detail::ObjectDestroy<PhysicalDevice, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -9673,7 +9675,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -9796,7 +9798,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains;
uniqueSwapchains.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & swapchain : swapchains )
{
uniqueSwapchains.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchain, deleter ) );
@ -9830,7 +9832,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains( swapchainKHRAllocator );
uniqueSwapchains.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & swapchain : swapchains )
{
uniqueSwapchains.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchain, deleter ) );
@ -9859,7 +9861,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>( swapchain, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>( swapchain, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -9924,7 +9926,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -10016,7 +10018,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -10112,7 +10114,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -10205,7 +10207,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -10271,7 +10273,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -10344,7 +10346,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>( callback, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>( callback, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -10765,7 +10768,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>( videoSession, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>( videoSession, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -11021,7 +11024,7 @@ namespace VULKAN_HPP_NAMESPACE
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result,
UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>(
videoSessionParameters, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
videoSessionParameters, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -11450,7 +11453,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVXUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>( module, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>( module, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -11512,7 +11515,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVXUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>( function, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>( function, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -11946,7 +11949,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGPUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -12618,7 +12621,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNNUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -13218,7 +13221,7 @@ namespace VULKAN_HPP_NAMESPACE
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result,
UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>(
descriptorUpdateTemplate, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
descriptorUpdateTemplate, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -13413,7 +13416,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( display, ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( display, detail::ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -13541,7 +13544,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -13609,7 +13612,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -13921,7 +13924,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( renderPass, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( renderPass, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -14981,7 +14984,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVKUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -15047,7 +15050,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVKUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -15269,7 +15272,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>( messenger, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>( messenger, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -15588,7 +15592,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipeline : pipelines )
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
@ -15626,7 +15630,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipeline : pipelines )
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
@ -15659,7 +15663,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -16113,9 +16117,9 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>( accelerationStructure, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result,
UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>(
accelerationStructure, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -16947,7 +16951,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipeline : pipelines )
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
@ -16990,7 +16994,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipeline : pipelines )
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
@ -17028,7 +17032,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -17264,7 +17268,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>( ycbcrConversion, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>( ycbcrConversion, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -17448,7 +17453,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>( validationCache, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>( validationCache, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -17754,9 +17760,9 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNVUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>( accelerationStructure, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result,
UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>(
accelerationStructure, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -18132,7 +18138,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipeline : pipelines )
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
@ -18169,7 +18175,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipeline : pipelines )
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
@ -18202,7 +18208,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -19209,7 +19215,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTELUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>( configuration, ObjectRelease<Device, Dispatch>( *this, d ) ) );
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>( configuration, detail::ObjectRelease<Device, Dispatch>( *this, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -19397,7 +19404,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIAUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -19463,7 +19470,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -20215,7 +20222,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -20558,7 +20565,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>( deferredOperation, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>( deferredOperation, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -21416,7 +21424,7 @@ namespace VULKAN_HPP_NAMESPACE
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result,
UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>(
indirectCommandsLayout, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
indirectCommandsLayout, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -21577,7 +21585,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( display, ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( display, detail::ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -21641,7 +21649,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>( privateDataSlot, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>( privateDataSlot, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -22080,7 +22089,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaModuleNVUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::CudaModuleNV, Dispatch>( module, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::CudaModuleNV, Dispatch>( module, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -22220,7 +22229,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaFunctionNVUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::CudaFunctionNV, Dispatch>( function, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::CudaFunctionNV, Dispatch>( function, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -23145,7 +23154,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( display, ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( display, detail::ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -23211,7 +23220,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -23478,7 +23487,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIAUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>( collection, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA, Dispatch>( collection, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -23855,7 +23865,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNXUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -24065,7 +24075,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createMicromapEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::MicromapEXT, Dispatch>( micromap, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::MicromapEXT, Dispatch>( micromap, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -25594,7 +25604,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createOpticalFlowSessionNVUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV, Dispatch>( session, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV, Dispatch>( session, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -26018,7 +26028,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator> uniqueShaders;
uniqueShaders.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & shader : shaders )
{
uniqueShaders.push_back( UniqueHandle<ShaderEXT, Dispatch>( shader, deleter ) );
@ -26053,7 +26063,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>, ShaderEXTAllocator> uniqueShaders( shaderEXTAllocator );
uniqueShaders.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & shader : shaders )
{
uniqueShaders.push_back( UniqueHandle<ShaderEXT, Dispatch>( shader, deleter ) );
@ -26084,7 +26094,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT } );
return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>( shader, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>( shader, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -26474,7 +26484,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete, VULKAN_HPP_NAMESPACE::Result::ePipelineBinaryMissingKHR } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator> uniquePipelineBinaries;
uniquePipelineBinaries.reserve( pipelineBinaries.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipelineBinary : pipelineBinaries )
{
uniquePipelineBinaries.push_back( UniqueHandle<PipelineBinaryKHR, Dispatch>( pipelineBinary, deleter ) );
@ -26541,7 +26551,7 @@ namespace VULKAN_HPP_NAMESPACE
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR, Dispatch>, PipelineBinaryKHRAllocator> uniquePipelineBinaries(
pipelineBinaryKHRAllocator );
uniquePipelineBinaries.reserve( pipelineBinaries.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipelineBinary : pipelineBinaries )
{
uniquePipelineBinaries.push_back( UniqueHandle<PipelineBinaryKHR, Dispatch>( pipelineBinary, deleter ) );
@ -27686,7 +27696,7 @@ namespace VULKAN_HPP_NAMESPACE
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result,
UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT, Dispatch>(
indirectCommandsLayout, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
indirectCommandsLayout, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -27806,9 +27816,9 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkIndirectExecutionSetEXT *>( &indirectExecutionSet ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectExecutionSetEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT, Dispatch>( indirectExecutionSet, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result,
UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT, Dispatch>(
indirectExecutionSet, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

100
vulkan/vulkan_handles.hpp
View File

@ -2031,7 +2031,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Instance, Dispatch>
{
public:
using deleter = ObjectDestroy<NoParent, Dispatch>;
using deleter = detail::ObjectDestroy<detail::NoParent, Dispatch>;
};
using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2040,7 +2040,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Device, Dispatch>
{
public:
using deleter = ObjectDestroy<NoParent, Dispatch>;
using deleter = detail::ObjectDestroy<detail::NoParent, Dispatch>;
};
using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2049,7 +2049,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<DeviceMemory, Dispatch>
{
public:
using deleter = ObjectFree<Device, Dispatch>;
using deleter = detail::ObjectFree<Device, Dispatch>;
};
using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2058,7 +2058,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Fence, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2067,7 +2067,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Semaphore, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2076,7 +2076,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Event, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2085,7 +2085,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<QueryPool, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2094,7 +2094,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Buffer, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2103,7 +2103,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<BufferView, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2112,7 +2112,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Image, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2121,7 +2121,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<ImageView, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2130,7 +2130,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<ShaderModule, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2139,7 +2139,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<PipelineCache, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2148,7 +2148,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Pipeline, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2157,7 +2157,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<PipelineLayout, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2166,7 +2166,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Sampler, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2175,7 +2175,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<DescriptorPool, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2184,7 +2184,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<DescriptorSet, Dispatch>
{
public:
using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
using deleter = detail::PoolFree<Device, DescriptorPool, Dispatch>;
};
using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2193,7 +2193,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2202,7 +2202,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Framebuffer, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2211,7 +2211,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<RenderPass, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2220,7 +2220,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<CommandPool, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2229,7 +2229,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<CommandBuffer, Dispatch>
{
public:
using deleter = PoolFree<Device, CommandPool, Dispatch>;
using deleter = detail::PoolFree<Device, CommandPool, Dispatch>;
};
using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2239,7 +2239,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2249,7 +2249,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueDescriptorUpdateTemplate = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2260,7 +2260,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<PrivateDataSlot, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniquePrivateDataSlot = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2271,7 +2271,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<SurfaceKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Instance, Dispatch>;
using deleter = detail::ObjectDestroy<Instance, Dispatch>;
};
using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2281,7 +2281,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<SwapchainKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2291,7 +2291,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<DisplayKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<PhysicalDevice, Dispatch>;
using deleter = detail::ObjectDestroy<PhysicalDevice, Dispatch>;
};
using UniqueDisplayKHR = UniqueHandle<DisplayKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2301,7 +2301,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Instance, Dispatch>;
using deleter = detail::ObjectDestroy<Instance, Dispatch>;
};
using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2311,7 +2311,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<VideoSessionKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2320,7 +2320,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2330,7 +2330,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<CuModuleNVX, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2339,7 +2339,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<CuFunctionNVX, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2349,7 +2349,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Instance, Dispatch>;
using deleter = detail::ObjectDestroy<Instance, Dispatch>;
};
using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2359,7 +2359,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2369,7 +2369,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2379,7 +2379,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2389,7 +2389,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<PerformanceConfigurationINTEL, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniquePerformanceConfigurationINTEL = UniqueHandle<PerformanceConfigurationINTEL, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2399,7 +2399,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2409,7 +2409,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2420,7 +2420,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<CudaModuleNV, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueCudaModuleNV = UniqueHandle<CudaModuleNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2429,7 +2429,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<CudaFunctionNV, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueCudaFunctionNV = UniqueHandle<CudaFunctionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2441,7 +2441,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2452,7 +2452,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<MicromapEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2462,7 +2462,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<OpticalFlowSessionNV, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueOpticalFlowSessionNV = UniqueHandle<OpticalFlowSessionNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2472,7 +2472,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<ShaderEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueShaderEXT = UniqueHandle<ShaderEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2482,7 +2482,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<PipelineBinaryKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniquePipelineBinaryKHR = UniqueHandle<PipelineBinaryKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2492,7 +2492,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<IndirectCommandsLayoutEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueIndirectCommandsLayoutEXT = UniqueHandle<IndirectCommandsLayoutEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -2501,7 +2501,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<IndirectExecutionSetEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueIndirectExecutionSetEXT = UniqueHandle<IndirectExecutionSetEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

350
vulkan/vulkan_shared.hpp
View File

@ -308,8 +308,8 @@ namespace VULKAN_HPP_NAMESPACE
using BaseType::internalDestroy;
};
template <typename HandleType>
class SharedHandleTraits;
namespace detail
{
// Silence the function cast warnings.
# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
@ -317,150 +317,152 @@ namespace VULKAN_HPP_NAMESPACE
# pragma GCC diagnostic ignored "-Wcast-function-type"
# endif
template <typename HandleType>
class ObjectDestroyShared
{
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
template <class Dispatcher>
using DestroyFunctionPointerType =
typename std::conditional<HasDestructor<HandleType>::value,
void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const,
void ( HandleType::* )( const AllocationCallbacks *, const Dispatcher & ) const>::type;
using SelectorType = typename std::conditional<HasDestructor<HandleType>::value, DestructorType, HandleType>::type;
template <typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ObjectDestroyShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &SelectorType::destroy ) ) )
, m_dispatch( &dispatch )
, m_allocationCallbacks( allocationCallbacks )
template <typename HandleType>
class ObjectDestroyShared
{
}
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
public:
template <typename T = HandleType>
typename std::enable_if<HasDestructor<T>::value, void>::type destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
template <class Dispatcher>
using DestroyFunctionPointerType =
typename std::conditional<HasDestructor<HandleType>::value,
void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const,
void ( HandleType::* )( const AllocationCallbacks *, const Dispatcher & ) const>::type;
using SelectorType = typename std::conditional<HasDestructor<HandleType>::value, DestructorType, HandleType>::type;
template <typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ObjectDestroyShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &SelectorType::destroy ) ) )
, m_dispatch( &dispatch )
, m_allocationCallbacks( allocationCallbacks )
{
}
public:
template <typename T = HandleType>
typename std::enable_if<HasDestructor<T>::value, void>::type destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
}
template <typename T = HandleType>
typename std::enable_if<!HasDestructor<T>::value, void>::type destroy( HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( handle.*m_destroy )( m_allocationCallbacks, *m_dispatch );
}
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
};
template <typename HandleType>
class ObjectFreeShared
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
}
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
template <typename T = HandleType>
typename std::enable_if<!HasDestructor<T>::value, void>::type destroy( HandleType handle ) const VULKAN_HPP_NOEXCEPT
template <class Dispatcher>
using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const;
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
, m_dispatch( &dispatch )
, m_allocationCallbacks( allocationCallbacks )
{
}
public:
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
}
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
};
template <typename HandleType>
class ObjectReleaseShared
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( handle.*m_destroy )( m_allocationCallbacks, *m_dispatch );
}
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
};
template <class Dispatcher>
using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const;
template <typename HandleType>
class ObjectFreeShared
{
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ObjectReleaseShared( const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::release ) ) )
, m_dispatch( &dispatch )
{
}
template <class Dispatcher>
using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const;
public:
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( parent.*m_destroy )( handle, *m_dispatch );
}
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
, m_dispatch( &dispatch )
, m_allocationCallbacks( allocationCallbacks )
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
};
template <typename HandleType, typename PoolType>
class PoolFreeShared
{
}
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
public:
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
}
using PoolTypeExport = PoolType;
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
};
template <class Dispatcher>
using ReturnType = decltype( std::declval<DestructorType>().free( PoolType(), 0u, nullptr, Dispatcher() ) );
template <typename HandleType>
class ObjectReleaseShared
{
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
template <class Dispatcher>
using DestroyFunctionPointerType = ReturnType<Dispatcher> ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const;
template <class Dispatcher>
using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const;
PoolFreeShared() = default;
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ObjectReleaseShared( const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::release ) ) )
, m_dispatch( &dispatch )
{
}
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
PoolFreeShared( SharedHandle<PoolType> pool, const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
, m_dispatch( &dispatch )
, m_pool( std::move( pool ) )
{
}
public:
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( parent.*m_destroy )( handle, *m_dispatch );
}
public:
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch && m_pool );
( parent.*m_destroy )( m_pool.get(), 1u, &handle, *m_dispatch );
}
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
};
template <typename HandleType, typename PoolType>
class PoolFreeShared
{
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
using PoolTypeExport = PoolType;
template <class Dispatcher>
using ReturnType = decltype( std::declval<DestructorType>().free( PoolType(), 0u, nullptr, Dispatcher() ) );
template <class Dispatcher>
using DestroyFunctionPointerType = ReturnType<Dispatcher> ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const;
PoolFreeShared() = default;
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
PoolFreeShared( SharedHandle<PoolType> pool, const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
, m_dispatch( &dispatch )
, m_pool( std::move( pool ) )
{
}
public:
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch && m_pool );
( parent.*m_destroy )( m_pool.get(), 1u, &handle, *m_dispatch );
}
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
SharedHandle<PoolType> m_pool{};
};
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
SharedHandle<PoolType> m_pool{};
};
# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
# pragma GCC diagnostic pop
# endif
} // namespace detail
//======================
//=== SHARED HANDLEs ===
//======================
@ -471,7 +473,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = NoDestructor;
using deleter = ObjectDestroyShared<Instance>;
using deleter = detail::ObjectDestroyShared<Instance>;
};
using SharedInstance = SharedHandle<Instance>;
@ -481,7 +483,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = NoDestructor;
using deleter = ObjectDestroyShared<Device>;
using deleter = detail::ObjectDestroyShared<Device>;
};
using SharedDevice = SharedHandle<Device>;
@ -491,7 +493,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectFreeShared<DeviceMemory>;
using deleter = detail::ObjectFreeShared<DeviceMemory>;
};
using SharedDeviceMemory = SharedHandle<DeviceMemory>;
@ -501,7 +503,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Fence>;
using deleter = detail::ObjectDestroyShared<Fence>;
};
using SharedFence = SharedHandle<Fence>;
@ -511,7 +513,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Semaphore>;
using deleter = detail::ObjectDestroyShared<Semaphore>;
};
using SharedSemaphore = SharedHandle<Semaphore>;
@ -521,7 +523,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Event>;
using deleter = detail::ObjectDestroyShared<Event>;
};
using SharedEvent = SharedHandle<Event>;
@ -531,7 +533,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<QueryPool>;
using deleter = detail::ObjectDestroyShared<QueryPool>;
};
using SharedQueryPool = SharedHandle<QueryPool>;
@ -541,7 +543,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Buffer>;
using deleter = detail::ObjectDestroyShared<Buffer>;
};
using SharedBuffer = SharedHandle<Buffer>;
@ -551,7 +553,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<BufferView>;
using deleter = detail::ObjectDestroyShared<BufferView>;
};
using SharedBufferView = SharedHandle<BufferView>;
@ -561,7 +563,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Image>;
using deleter = detail::ObjectDestroyShared<Image>;
};
using SharedImage = SharedHandle<Image>;
@ -571,7 +573,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<ImageView>;
using deleter = detail::ObjectDestroyShared<ImageView>;
};
using SharedImageView = SharedHandle<ImageView>;
@ -581,7 +583,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<ShaderModule>;
using deleter = detail::ObjectDestroyShared<ShaderModule>;
};
using SharedShaderModule = SharedHandle<ShaderModule>;
@ -591,7 +593,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<PipelineCache>;
using deleter = detail::ObjectDestroyShared<PipelineCache>;
};
using SharedPipelineCache = SharedHandle<PipelineCache>;
@ -601,7 +603,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Pipeline>;
using deleter = detail::ObjectDestroyShared<Pipeline>;
};
using SharedPipeline = SharedHandle<Pipeline>;
@ -611,7 +613,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<PipelineLayout>;
using deleter = detail::ObjectDestroyShared<PipelineLayout>;
};
using SharedPipelineLayout = SharedHandle<PipelineLayout>;
@ -621,7 +623,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Sampler>;
using deleter = detail::ObjectDestroyShared<Sampler>;
};
using SharedSampler = SharedHandle<Sampler>;
@ -631,7 +633,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<DescriptorPool>;
using deleter = detail::ObjectDestroyShared<DescriptorPool>;
};
using SharedDescriptorPool = SharedHandle<DescriptorPool>;
@ -641,7 +643,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = PoolFreeShared<DescriptorSet, DescriptorPool>;
using deleter = detail::PoolFreeShared<DescriptorSet, DescriptorPool>;
};
using SharedDescriptorSet = SharedHandle<DescriptorSet>;
@ -651,7 +653,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<DescriptorSetLayout>;
using deleter = detail::ObjectDestroyShared<DescriptorSetLayout>;
};
using SharedDescriptorSetLayout = SharedHandle<DescriptorSetLayout>;
@ -661,7 +663,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Framebuffer>;
using deleter = detail::ObjectDestroyShared<Framebuffer>;
};
using SharedFramebuffer = SharedHandle<Framebuffer>;
@ -671,7 +673,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<RenderPass>;
using deleter = detail::ObjectDestroyShared<RenderPass>;
};
using SharedRenderPass = SharedHandle<RenderPass>;
@ -681,7 +683,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<CommandPool>;
using deleter = detail::ObjectDestroyShared<CommandPool>;
};
using SharedCommandPool = SharedHandle<CommandPool>;
@ -691,7 +693,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = PoolFreeShared<CommandBuffer, CommandPool>;
using deleter = detail::PoolFreeShared<CommandBuffer, CommandPool>;
};
using SharedCommandBuffer = SharedHandle<CommandBuffer>;
@ -702,7 +704,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<SamplerYcbcrConversion>;
using deleter = detail::ObjectDestroyShared<SamplerYcbcrConversion>;
};
using SharedSamplerYcbcrConversion = SharedHandle<SamplerYcbcrConversion>;
@ -713,7 +715,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<DescriptorUpdateTemplate>;
using deleter = detail::ObjectDestroyShared<DescriptorUpdateTemplate>;
};
using SharedDescriptorUpdateTemplate = SharedHandle<DescriptorUpdateTemplate>;
@ -725,7 +727,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<PrivateDataSlot>;
using deleter = detail::ObjectDestroyShared<PrivateDataSlot>;
};
using SharedPrivateDataSlot = SharedHandle<PrivateDataSlot>;
@ -737,7 +739,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Instance;
using deleter = ObjectDestroyShared<SurfaceKHR>;
using deleter = detail::ObjectDestroyShared<SurfaceKHR>;
};
using SharedSurfaceKHR = SharedHandle<SurfaceKHR>;
@ -748,7 +750,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<SwapchainKHR>;
using deleter = detail::ObjectDestroyShared<SwapchainKHR>;
};
using SharedSwapchainKHR = SharedHandle<SwapchainKHR>;
@ -759,7 +761,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = PhysicalDevice;
using deleter = ObjectDestroyShared<DisplayKHR>;
using deleter = detail::ObjectDestroyShared<DisplayKHR>;
};
using SharedDisplayKHR = SharedHandle<DisplayKHR>;
@ -770,7 +772,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Instance;
using deleter = ObjectDestroyShared<DebugReportCallbackEXT>;
using deleter = detail::ObjectDestroyShared<DebugReportCallbackEXT>;
};
using SharedDebugReportCallbackEXT = SharedHandle<DebugReportCallbackEXT>;
@ -781,7 +783,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<VideoSessionKHR>;
using deleter = detail::ObjectDestroyShared<VideoSessionKHR>;
};
using SharedVideoSessionKHR = SharedHandle<VideoSessionKHR>;
@ -791,7 +793,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<VideoSessionParametersKHR>;
using deleter = detail::ObjectDestroyShared<VideoSessionParametersKHR>;
};
using SharedVideoSessionParametersKHR = SharedHandle<VideoSessionParametersKHR>;
@ -802,7 +804,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<CuModuleNVX>;
using deleter = detail::ObjectDestroyShared<CuModuleNVX>;
};
using SharedCuModuleNVX = SharedHandle<CuModuleNVX>;
@ -812,7 +814,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<CuFunctionNVX>;
using deleter = detail::ObjectDestroyShared<CuFunctionNVX>;
};
using SharedCuFunctionNVX = SharedHandle<CuFunctionNVX>;
@ -823,7 +825,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Instance;
using deleter = ObjectDestroyShared<DebugUtilsMessengerEXT>;
using deleter = detail::ObjectDestroyShared<DebugUtilsMessengerEXT>;
};
using SharedDebugUtilsMessengerEXT = SharedHandle<DebugUtilsMessengerEXT>;
@ -834,7 +836,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<AccelerationStructureKHR>;
using deleter = detail::ObjectDestroyShared<AccelerationStructureKHR>;
};
using SharedAccelerationStructureKHR = SharedHandle<AccelerationStructureKHR>;
@ -845,7 +847,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<ValidationCacheEXT>;
using deleter = detail::ObjectDestroyShared<ValidationCacheEXT>;
};
using SharedValidationCacheEXT = SharedHandle<ValidationCacheEXT>;
@ -856,7 +858,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<AccelerationStructureNV>;
using deleter = detail::ObjectDestroyShared<AccelerationStructureNV>;
};
using SharedAccelerationStructureNV = SharedHandle<AccelerationStructureNV>;
@ -867,7 +869,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<PerformanceConfigurationINTEL>;
using deleter = detail::ObjectDestroyShared<PerformanceConfigurationINTEL>;
};
using SharedPerformanceConfigurationINTEL = SharedHandle<PerformanceConfigurationINTEL>;
@ -878,7 +880,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<DeferredOperationKHR>;
using deleter = detail::ObjectDestroyShared<DeferredOperationKHR>;
};
using SharedDeferredOperationKHR = SharedHandle<DeferredOperationKHR>;
@ -889,7 +891,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<IndirectCommandsLayoutNV>;
using deleter = detail::ObjectDestroyShared<IndirectCommandsLayoutNV>;
};
using SharedIndirectCommandsLayoutNV = SharedHandle<IndirectCommandsLayoutNV>;
@ -901,7 +903,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<CudaModuleNV>;
using deleter = detail::ObjectDestroyShared<CudaModuleNV>;
};
using SharedCudaModuleNV = SharedHandle<CudaModuleNV>;
@ -911,7 +913,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<CudaFunctionNV>;
using deleter = detail::ObjectDestroyShared<CudaFunctionNV>;
};
using SharedCudaFunctionNV = SharedHandle<CudaFunctionNV>;
@ -924,7 +926,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<BufferCollectionFUCHSIA>;
using deleter = detail::ObjectDestroyShared<BufferCollectionFUCHSIA>;
};
using SharedBufferCollectionFUCHSIA = SharedHandle<BufferCollectionFUCHSIA>;
@ -936,7 +938,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<MicromapEXT>;
using deleter = detail::ObjectDestroyShared<MicromapEXT>;
};
using SharedMicromapEXT = SharedHandle<MicromapEXT>;
@ -947,7 +949,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<OpticalFlowSessionNV>;
using deleter = detail::ObjectDestroyShared<OpticalFlowSessionNV>;
};
using SharedOpticalFlowSessionNV = SharedHandle<OpticalFlowSessionNV>;
@ -958,7 +960,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<ShaderEXT>;
using deleter = detail::ObjectDestroyShared<ShaderEXT>;
};
using SharedShaderEXT = SharedHandle<ShaderEXT>;
@ -969,7 +971,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<PipelineBinaryKHR>;
using deleter = detail::ObjectDestroyShared<PipelineBinaryKHR>;
};
using SharedPipelineBinaryKHR = SharedHandle<PipelineBinaryKHR>;
@ -980,7 +982,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<IndirectCommandsLayoutEXT>;
using deleter = detail::ObjectDestroyShared<IndirectCommandsLayoutEXT>;
};
using SharedIndirectCommandsLayoutEXT = SharedHandle<IndirectCommandsLayoutEXT>;
@ -990,7 +992,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<IndirectExecutionSetEXT>;
using deleter = detail::ObjectDestroyShared<IndirectExecutionSetEXT>;
};
using SharedIndirectExecutionSetEXT = SharedHandle<IndirectExecutionSetEXT>;

20
vulkan/vulkansc.cppm
View File

@ -59,14 +59,18 @@ export namespace VULKAN_HPP_NAMESPACE
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
using VULKAN_HPP_NAMESPACE::ObjectDestroy;
using VULKAN_HPP_NAMESPACE::ObjectDestroyShared;
using VULKAN_HPP_NAMESPACE::ObjectFree;
using VULKAN_HPP_NAMESPACE::ObjectFreeShared;
using VULKAN_HPP_NAMESPACE::ObjectRelease;
using VULKAN_HPP_NAMESPACE::ObjectReleaseShared;
using VULKAN_HPP_NAMESPACE::PoolFree;
using VULKAN_HPP_NAMESPACE::PoolFreeShared;
namespace detail
{
using VULKAN_HPP_NAMESPACE::detail::ObjectDestroy;
using VULKAN_HPP_NAMESPACE::detail::ObjectDestroyShared;
using VULKAN_HPP_NAMESPACE::detail::ObjectFree;
using VULKAN_HPP_NAMESPACE::detail::ObjectFreeShared;
using VULKAN_HPP_NAMESPACE::detail::ObjectRelease;
using VULKAN_HPP_NAMESPACE::detail::ObjectReleaseShared;
using VULKAN_HPP_NAMESPACE::detail::PoolFree;
using VULKAN_HPP_NAMESPACE::detail::PoolFreeShared;
} // namespace detail
using VULKAN_HPP_NAMESPACE::SharedHandle;
using VULKAN_HPP_NAMESPACE::UniqueHandle;
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/

373
vulkan/vulkansc.hpp
View File

@ -3164,208 +3164,211 @@ namespace VULKAN_HPP_NAMESPACE
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
struct AllocationCallbacks;
template <typename OwnerType, typename Dispatch>
class ObjectDestroy
namespace detail
{
public:
ObjectDestroy() = default;
ObjectDestroy( OwnerType owner,
Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
template <typename OwnerType, typename Dispatch>
class ObjectDestroy
{
}
public:
ObjectDestroy() = default;
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
ObjectDestroy( OwnerType owner,
Optional<const vk::AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
Optional<const vk::AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
}
private:
OwnerType m_owner = {};
Optional<const vk::AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
class NoParent;
template <typename Dispatch>
class ObjectDestroy<NoParent, Dispatch>
{
return m_owner;
}
public:
ObjectDestroy() = default;
Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
ObjectDestroy( Optional<const vk::AllocationCallbacks> allocationCallbacks,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{
}
Optional<const vk::AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_dispatch );
t.destroy( m_allocationCallbacks, *m_dispatch );
}
private:
Optional<const vk::AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename Dispatch>
class ObjectFree
{
return m_allocationCallbacks;
}
public:
ObjectFree() = default;
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
ObjectFree( OwnerType owner,
Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
( m_owner.free )( t, m_allocationCallbacks, *m_dispatch );
}
private:
OwnerType m_owner = {};
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename Dispatch>
class ObjectRelease
{
return *m_dispatch;
}
public:
ObjectRelease() = default;
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
ObjectRelease( OwnerType owner, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
m_owner.release( t, *m_dispatch );
}
private:
OwnerType m_owner = {};
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename PoolType, typename Dispatch>
class PoolFree
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
}
public:
PoolFree() = default;
private:
OwnerType m_owner = {};
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
PoolFree( OwnerType owner, PoolType pool, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_pool( pool )
, m_dispatch( &dispatch )
{
}
class NoParent;
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
template <typename Dispatch>
class ObjectDestroy<NoParent, Dispatch>
{
public:
ObjectDestroy() = default;
PoolType getPool() const VULKAN_HPP_NOEXCEPT
{
return m_pool;
}
ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
( m_owner.free )( m_pool, t, *m_dispatch );
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_dispatch );
t.destroy( m_allocationCallbacks, *m_dispatch );
}
private:
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename Dispatch>
class ObjectFree
{
public:
ObjectFree() = default;
ObjectFree( OwnerType owner,
Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
( m_owner.free )( t, m_allocationCallbacks, *m_dispatch );
}
private:
OwnerType m_owner = {};
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename Dispatch>
class ObjectRelease
{
public:
ObjectRelease() = default;
ObjectRelease( OwnerType owner, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_owner && m_dispatch );
m_owner.release( t, *m_dispatch );
}
private:
OwnerType m_owner = {};
Dispatch const * m_dispatch = nullptr;
};
template <typename OwnerType, typename PoolType, typename Dispatch>
class PoolFree
{
public:
PoolFree() = default;
PoolFree( OwnerType owner, PoolType pool, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_pool( pool )
, m_dispatch( &dispatch )
{
}
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
{
return m_owner;
}
PoolType getPool() const VULKAN_HPP_NOEXCEPT
{
return m_pool;
}
Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
{
return *m_dispatch;
}
protected:
template <typename T>
void destroy( T t ) VULKAN_HPP_NOEXCEPT
{
( m_owner.free )( m_pool, t, *m_dispatch );
}
private:
OwnerType m_owner = OwnerType();
PoolType m_pool = PoolType();
Dispatch const * m_dispatch = nullptr;
};
private:
OwnerType m_owner = OwnerType();
PoolType m_pool = PoolType();
Dispatch const * m_dispatch = nullptr;
};
} // namespace detail
#endif // !VULKAN_HPP_NO_SMART_HANDLE
//==================

92
vulkan/vulkansc_funcs.hpp
View File

@ -70,7 +70,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::createInstanceUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>( instance, ObjectDestroy<NoParent, Dispatch>( allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>( instance, detail::ObjectDestroy<detail::NoParent, Dispatch>( allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -490,7 +490,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDeviceUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>( device, ObjectDestroy<NoParent, Dispatch>( allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>( device, detail::ObjectDestroy<detail::NoParent, Dispatch>( allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -982,7 +982,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemoryUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>( memory, ObjectFree<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>( memory, detail::ObjectFree<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -1287,7 +1287,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFenceUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -1486,7 +1486,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphoreUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>( semaphore, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>( semaphore, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -1598,7 +1598,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createEventUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>( event, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>( event, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -1783,7 +1783,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPoolUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>( queryPool, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>( queryPool, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -1927,7 +1927,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>( buffer, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>( buffer, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -2041,7 +2041,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferViewUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>( view, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>( view, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -2153,7 +2153,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>( image, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>( image, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -2300,7 +2300,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageViewUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>( view, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>( view, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -2416,7 +2416,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCacheUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>( pipelineCache, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>( pipelineCache, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -2608,7 +2608,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipeline : pipelines )
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
@ -2645,7 +2645,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipeline : pipelines )
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
@ -2678,7 +2678,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -2816,7 +2816,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines;
uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipeline : pipelines )
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
@ -2853,7 +2853,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>, PipelineAllocator> uniquePipelines( pipelineAllocator );
uniquePipelines.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & pipeline : pipelines )
{
uniquePipelines.push_back( UniqueHandle<Pipeline, Dispatch>( pipeline, deleter ) );
@ -2886,7 +2886,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } );
return ResultValue<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>( pipeline, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3002,7 +3002,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayoutUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>( pipelineLayout, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>( pipelineLayout, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3114,7 +3114,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>( sampler, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>( sampler, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3228,7 +3228,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayoutUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>( setLayout, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>( setLayout, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3348,7 +3348,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPoolUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>( descriptorPool, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>( descriptorPool, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3451,7 +3451,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets;
uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount );
PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
detail::PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
for ( auto const & descriptorSet : descriptorSets )
{
uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSet, deleter ) );
@ -3481,7 +3481,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>, DescriptorSetAllocator> uniqueDescriptorSets( descriptorSetAllocator );
uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount );
PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
detail::PoolFree<Device, DescriptorPool, Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
for ( auto const & descriptorSet : descriptorSets )
{
uniqueDescriptorSets.push_back( UniqueHandle<DescriptorSet, Dispatch>( descriptorSet, deleter ) );
@ -3641,7 +3641,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebufferUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>( framebuffer, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>( framebuffer, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3757,7 +3757,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPassUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( renderPass, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( renderPass, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -3899,7 +3899,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPoolUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>( commandPool, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>( commandPool, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -4005,7 +4005,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers;
uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount );
PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d );
detail::PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d );
for ( auto const & commandBuffer : commandBuffers )
{
uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffer, deleter ) );
@ -4035,7 +4035,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>, CommandBufferAllocator> uniqueCommandBuffers( commandBufferAllocator );
uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount );
PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d );
detail::PoolFree<Device, CommandPool, Dispatch> deleter( *this, allocateInfo.commandPool, d );
for ( auto const & commandBuffer : commandBuffers )
{
uniqueCommandBuffers.push_back( UniqueHandle<CommandBuffer, Dispatch>( commandBuffer, deleter ) );
@ -5932,7 +5932,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>( ycbcrConversion, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>( ycbcrConversion, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -6239,7 +6240,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2Unique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( renderPass, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>( renderPass, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -6633,7 +6634,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>( privateDataSlot, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlot, Dispatch>( privateDataSlot, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -7905,7 +7907,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>( swapchain, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>( swapchain, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -8635,7 +8637,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>( mode, ObjectDestroy<PhysicalDevice, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>( mode, detail::ObjectDestroy<PhysicalDevice, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -8730,7 +8732,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -8853,7 +8855,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains;
uniqueSwapchains.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & swapchain : swapchains )
{
uniqueSwapchains.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchain, deleter ) );
@ -8887,7 +8889,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
std::vector<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>, SwapchainKHRAllocator> uniqueSwapchains( swapchainKHRAllocator );
uniqueSwapchains.reserve( createInfos.size() );
ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
detail::ObjectDestroy<Device, Dispatch> deleter( *this, allocator, d );
for ( auto const & swapchain : swapchains )
{
uniqueSwapchains.push_back( UniqueHandle<SwapchainKHR, Dispatch>( swapchain, deleter ) );
@ -8916,7 +8918,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHRUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>( swapchain, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>( swapchain, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -9185,7 +9187,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -9253,7 +9255,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>( fence, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -10415,7 +10417,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>( messenger, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>( messenger, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -10816,7 +10819,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXTUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -11469,7 +11472,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( display, ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) );
result, UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>( display, detail::ObjectRelease<PhysicalDevice, Dispatch>( *this, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -11936,7 +11939,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphoreSciSyncPoolNVUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
result, UniqueHandle<VULKAN_HPP_NAMESPACE::SemaphoreSciSyncPoolNV, Dispatch>( semaphorePool, ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
result,
UniqueHandle<VULKAN_HPP_NAMESPACE::SemaphoreSciSyncPoolNV, Dispatch>( semaphorePool, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

46
vulkan/vulkansc_handles.hpp
View File

@ -821,7 +821,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Instance, Dispatch>
{
public:
using deleter = ObjectDestroy<NoParent, Dispatch>;
using deleter = detail::ObjectDestroy<detail::NoParent, Dispatch>;
};
using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -830,7 +830,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Device, Dispatch>
{
public:
using deleter = ObjectDestroy<NoParent, Dispatch>;
using deleter = detail::ObjectDestroy<detail::NoParent, Dispatch>;
};
using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -839,7 +839,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Fence, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -848,7 +848,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Semaphore, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -857,7 +857,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Event, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -866,7 +866,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Buffer, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -875,7 +875,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<BufferView, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -884,7 +884,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Image, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -893,7 +893,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<ImageView, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -902,7 +902,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<PipelineCache, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -911,7 +911,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Pipeline, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -920,7 +920,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<PipelineLayout, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -929,7 +929,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Sampler, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -938,7 +938,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<DescriptorSet, Dispatch>
{
public:
using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
using deleter = detail::PoolFree<Device, DescriptorPool, Dispatch>;
};
using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -947,7 +947,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -956,7 +956,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<Framebuffer, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -965,7 +965,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<RenderPass, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -974,7 +974,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<CommandBuffer, Dispatch>
{
public:
using deleter = PoolFree<Device, CommandPool, Dispatch>;
using deleter = detail::PoolFree<Device, CommandPool, Dispatch>;
};
using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -984,7 +984,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueSamplerYcbcrConversion = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -995,7 +995,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<PrivateDataSlot, Dispatch>
{
public:
using deleter = ObjectDestroy<Device, Dispatch>;
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniquePrivateDataSlot = UniqueHandle<PrivateDataSlot, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -1006,7 +1006,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<SurfaceKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<Instance, Dispatch>;
using deleter = detail::ObjectDestroy<Instance, Dispatch>;
};
using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -1016,7 +1016,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<DisplayKHR, Dispatch>
{
public:
using deleter = ObjectDestroy<PhysicalDevice, Dispatch>;
using deleter = detail::ObjectDestroy<PhysicalDevice, Dispatch>;
};
using UniqueDisplayKHR = UniqueHandle<DisplayKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
@ -1026,7 +1026,7 @@ namespace VULKAN_HPP_NAMESPACE
class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
{
public:
using deleter = ObjectDestroy<Instance, Dispatch>;
using deleter = detail::ObjectDestroy<Instance, Dispatch>;
};
using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

296
vulkan/vulkansc_shared.hpp
View File

@ -308,8 +308,8 @@ namespace VULKAN_HPP_NAMESPACE
using BaseType::internalDestroy;
};
template <typename HandleType>
class SharedHandleTraits;
namespace detail
{
// Silence the function cast warnings.
# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
@ -317,150 +317,152 @@ namespace VULKAN_HPP_NAMESPACE
# pragma GCC diagnostic ignored "-Wcast-function-type"
# endif
template <typename HandleType>
class ObjectDestroyShared
{
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
template <class Dispatcher>
using DestroyFunctionPointerType =
typename std::conditional<HasDestructor<HandleType>::value,
void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const,
void ( HandleType::* )( const AllocationCallbacks *, const Dispatcher & ) const>::type;
using SelectorType = typename std::conditional<HasDestructor<HandleType>::value, DestructorType, HandleType>::type;
template <typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ObjectDestroyShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &SelectorType::destroy ) ) )
, m_dispatch( &dispatch )
, m_allocationCallbacks( allocationCallbacks )
template <typename HandleType>
class ObjectDestroyShared
{
}
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
public:
template <typename T = HandleType>
typename std::enable_if<HasDestructor<T>::value, void>::type destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
template <class Dispatcher>
using DestroyFunctionPointerType =
typename std::conditional<HasDestructor<HandleType>::value,
void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const,
void ( HandleType::* )( const AllocationCallbacks *, const Dispatcher & ) const>::type;
using SelectorType = typename std::conditional<HasDestructor<HandleType>::value, DestructorType, HandleType>::type;
template <typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ObjectDestroyShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &SelectorType::destroy ) ) )
, m_dispatch( &dispatch )
, m_allocationCallbacks( allocationCallbacks )
{
}
public:
template <typename T = HandleType>
typename std::enable_if<HasDestructor<T>::value, void>::type destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
}
template <typename T = HandleType>
typename std::enable_if<!HasDestructor<T>::value, void>::type destroy( HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( handle.*m_destroy )( m_allocationCallbacks, *m_dispatch );
}
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
};
template <typename HandleType>
class ObjectFreeShared
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
}
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
template <typename T = HandleType>
typename std::enable_if<!HasDestructor<T>::value, void>::type destroy( HandleType handle ) const VULKAN_HPP_NOEXCEPT
template <class Dispatcher>
using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const;
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
, m_dispatch( &dispatch )
, m_allocationCallbacks( allocationCallbacks )
{
}
public:
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
}
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
};
template <typename HandleType>
class ObjectReleaseShared
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( handle.*m_destroy )( m_allocationCallbacks, *m_dispatch );
}
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
};
template <class Dispatcher>
using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const;
template <typename HandleType>
class ObjectFreeShared
{
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ObjectReleaseShared( const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::release ) ) )
, m_dispatch( &dispatch )
{
}
template <class Dispatcher>
using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const;
public:
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( parent.*m_destroy )( handle, *m_dispatch );
}
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
, m_dispatch( &dispatch )
, m_allocationCallbacks( allocationCallbacks )
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
};
template <typename HandleType, typename PoolType>
class PoolFreeShared
{
}
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
public:
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
}
using PoolTypeExport = PoolType;
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
};
template <class Dispatcher>
using ReturnType = decltype( std::declval<DestructorType>().free( PoolType(), 0u, nullptr, Dispatcher() ) );
template <typename HandleType>
class ObjectReleaseShared
{
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
template <class Dispatcher>
using DestroyFunctionPointerType = ReturnType<Dispatcher> ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const;
template <class Dispatcher>
using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const;
PoolFreeShared() = default;
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ObjectReleaseShared( const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::release ) ) )
, m_dispatch( &dispatch )
{
}
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
PoolFreeShared( SharedHandle<PoolType> pool, const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
, m_dispatch( &dispatch )
, m_pool( std::move( pool ) )
{
}
public:
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
( parent.*m_destroy )( handle, *m_dispatch );
}
public:
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch && m_pool );
( parent.*m_destroy )( m_pool.get(), 1u, &handle, *m_dispatch );
}
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
};
template <typename HandleType, typename PoolType>
class PoolFreeShared
{
public:
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
using PoolTypeExport = PoolType;
template <class Dispatcher>
using ReturnType = decltype( std::declval<DestructorType>().free( PoolType(), 0u, nullptr, Dispatcher() ) );
template <class Dispatcher>
using DestroyFunctionPointerType = ReturnType<Dispatcher> ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const;
PoolFreeShared() = default;
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
PoolFreeShared( SharedHandle<PoolType> pool, const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
, m_dispatch( &dispatch )
, m_pool( std::move( pool ) )
{
}
public:
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( m_destroy && m_dispatch && m_pool );
( parent.*m_destroy )( m_pool.get(), 1u, &handle, *m_dispatch );
}
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
SharedHandle<PoolType> m_pool{};
};
private:
DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy = nullptr;
const detail::DispatchLoaderBase * m_dispatch = nullptr;
SharedHandle<PoolType> m_pool{};
};
# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
# pragma GCC diagnostic pop
# endif
} // namespace detail
//======================
//=== SHARED HANDLEs ===
//======================
@ -471,7 +473,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = NoDestructor;
using deleter = ObjectDestroyShared<Instance>;
using deleter = detail::ObjectDestroyShared<Instance>;
};
using SharedInstance = SharedHandle<Instance>;
@ -481,7 +483,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = NoDestructor;
using deleter = ObjectDestroyShared<Device>;
using deleter = detail::ObjectDestroyShared<Device>;
};
using SharedDevice = SharedHandle<Device>;
@ -491,7 +493,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Fence>;
using deleter = detail::ObjectDestroyShared<Fence>;
};
using SharedFence = SharedHandle<Fence>;
@ -501,7 +503,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Semaphore>;
using deleter = detail::ObjectDestroyShared<Semaphore>;
};
using SharedSemaphore = SharedHandle<Semaphore>;
@ -511,7 +513,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Event>;
using deleter = detail::ObjectDestroyShared<Event>;
};
using SharedEvent = SharedHandle<Event>;
@ -521,7 +523,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Buffer>;
using deleter = detail::ObjectDestroyShared<Buffer>;
};
using SharedBuffer = SharedHandle<Buffer>;
@ -531,7 +533,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<BufferView>;
using deleter = detail::ObjectDestroyShared<BufferView>;
};
using SharedBufferView = SharedHandle<BufferView>;
@ -541,7 +543,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Image>;
using deleter = detail::ObjectDestroyShared<Image>;
};
using SharedImage = SharedHandle<Image>;
@ -551,7 +553,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<ImageView>;
using deleter = detail::ObjectDestroyShared<ImageView>;
};
using SharedImageView = SharedHandle<ImageView>;
@ -561,7 +563,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<PipelineCache>;
using deleter = detail::ObjectDestroyShared<PipelineCache>;
};
using SharedPipelineCache = SharedHandle<PipelineCache>;
@ -571,7 +573,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Pipeline>;
using deleter = detail::ObjectDestroyShared<Pipeline>;
};
using SharedPipeline = SharedHandle<Pipeline>;
@ -581,7 +583,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<PipelineLayout>;
using deleter = detail::ObjectDestroyShared<PipelineLayout>;
};
using SharedPipelineLayout = SharedHandle<PipelineLayout>;
@ -591,7 +593,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Sampler>;
using deleter = detail::ObjectDestroyShared<Sampler>;
};
using SharedSampler = SharedHandle<Sampler>;
@ -601,7 +603,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = PoolFreeShared<DescriptorSet, DescriptorPool>;
using deleter = detail::PoolFreeShared<DescriptorSet, DescriptorPool>;
};
using SharedDescriptorSet = SharedHandle<DescriptorSet>;
@ -611,7 +613,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<DescriptorSetLayout>;
using deleter = detail::ObjectDestroyShared<DescriptorSetLayout>;
};
using SharedDescriptorSetLayout = SharedHandle<DescriptorSetLayout>;
@ -621,7 +623,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<Framebuffer>;
using deleter = detail::ObjectDestroyShared<Framebuffer>;
};
using SharedFramebuffer = SharedHandle<Framebuffer>;
@ -631,7 +633,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<RenderPass>;
using deleter = detail::ObjectDestroyShared<RenderPass>;
};
using SharedRenderPass = SharedHandle<RenderPass>;
@ -641,7 +643,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = PoolFreeShared<CommandBuffer, CommandPool>;
using deleter = detail::PoolFreeShared<CommandBuffer, CommandPool>;
};
using SharedCommandBuffer = SharedHandle<CommandBuffer>;
@ -652,7 +654,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<SamplerYcbcrConversion>;
using deleter = detail::ObjectDestroyShared<SamplerYcbcrConversion>;
};
using SharedSamplerYcbcrConversion = SharedHandle<SamplerYcbcrConversion>;
@ -664,7 +666,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Device;
using deleter = ObjectDestroyShared<PrivateDataSlot>;
using deleter = detail::ObjectDestroyShared<PrivateDataSlot>;
};
using SharedPrivateDataSlot = SharedHandle<PrivateDataSlot>;
@ -676,7 +678,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Instance;
using deleter = ObjectDestroyShared<SurfaceKHR>;
using deleter = detail::ObjectDestroyShared<SurfaceKHR>;
};
using SharedSurfaceKHR = SharedHandle<SurfaceKHR>;
@ -687,7 +689,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = PhysicalDevice;
using deleter = ObjectDestroyShared<DisplayKHR>;
using deleter = detail::ObjectDestroyShared<DisplayKHR>;
};
using SharedDisplayKHR = SharedHandle<DisplayKHR>;
@ -698,7 +700,7 @@ namespace VULKAN_HPP_NAMESPACE
{
public:
using DestructorType = Instance;
using deleter = ObjectDestroyShared<DebugUtilsMessengerEXT>;
using deleter = detail::ObjectDestroyShared<DebugUtilsMessengerEXT>;
};
using SharedDebugUtilsMessengerEXT = SharedHandle<DebugUtilsMessengerEXT>;