mirror of
https://github.com/KhronosGroup/Vulkan-Hpp.git
synced 2024-10-14 16:32:17 +00:00
Shared Handles (#1619)
* stage 1: added shared handles and all traits * moved deleter to the shared part, now Shared handle weights 2 pointers * Fixed Destroy Function * generated headers * At least no errors. TODO: get image overload of shared handle back make an example * fixed all SFINAE issues, moved image specialization * Added a sample * made better example, added specialization for swapchain, added shared handles to readme * Major update: Fixed all wishes Made std::shared_ptr do heavy lifting Reduced code complexity Added ParentType to basic handles Added put and put_native for cross-abi usage * more readme * safer release() removed put() for now * better synchronization inspired by STL shared_ptr implementation * removed test shared pointer * added forward type for better interop with VMA added parent checking * fixed getParent() * added non-deleting overloads for Queue, DisplayKHR and PhysicalDevice * Shared non-destoyed type now have handles * using constructors are made to comply standard * fixed leak * shared handles migrated to own header, made module entries * header is independent now * rebased repo, updated the example * fixed most of the stuff * renamed parent of, added guide to make shared handles * vulkansc * moved destructor to shared handle traits * resolved issues with CI * more relaxed memory ordering for release operation * trying to remove submodule * renamed to destructorType * suppressed function cast warning * only GCC should be affected
This commit is contained in:
Ilya Doroshenko
GitHub
parent
d60453f6ea
commit
5d0d3b7bd9
64
README.md
64
README.md
@ -436,6 +436,70 @@ For each function which constructs a Vulkan handle of type `vk::Type` Vulkan-Hpp
|
|||||||
|
|
||||||
Note that using `vk::UniqueHandle` comes at a cost since most deleters have to store the `vk::AllocationCallbacks` and parent handle used for construction because they are required for automatic destruction.
|
Note that using `vk::UniqueHandle` comes at a cost since most deleters have to store the `vk::AllocationCallbacks` and parent handle used for construction because they are required for automatic destruction.
|
||||||
|
|
||||||
|
### SharedHandle
|
||||||
|
|
||||||
|
Vulkan-Hpp provides a `vk::SharedHandle<Type>` interface. For each Vulkan handle type `vk::Type` there is a shared handle `vk::SharedType` which will delete the underlying Vulkan resource upon destruction, e.g. `vk::SharedBuffer` is the shared handle for `vk::Buffer`.
|
||||||
|
|
||||||
|
Unlike UniqueHandle, SharedHandle takes shared ownership of the resource as well as its parent. This means that parent handle will not be destroyed until all child resources are deleted. This is useful for resources that are shared between multiple threads or objects.
|
||||||
|
|
||||||
|
This mechanism ensures correct destruction order even if the parent SharedHandle is destroyed before its child handle. Otherwise, the handle behaves like `std::shared_ptr`. `vk::SharedInstance` or any of its child object should be last to delete (first created, first in class declaration)
|
||||||
|
|
||||||
|
There are no functions which return a `vk::SharedHandle` directly yet. Instead, you can construct a `vk::SharedHandle` from a `vk::Handle`:
|
||||||
|
|
||||||
|
```c++
|
||||||
|
|
||||||
|
vk::Buffer buffer = device.createBuffer(...);
|
||||||
|
vk::SharedBuffer sharedBuffer(buffer, device); // sharedBuffer now owns the buffer
|
||||||
|
```
|
||||||
|
|
||||||
|
There are several specializations of `vk::SharedHandle` for different handle types. For example, `vk::SharedImage` may take an additional argument to specify if the image is owned by swapchain:
|
||||||
|
|
||||||
|
```c++
|
||||||
|
vk::Image image = swapchain.getImages(...)[0]; // get the first image from the swapchain
|
||||||
|
vk::SharedImage sharedImage(image, device, SwapChainOwns::yes); // sharedImage now owns the image, but won't destroy it
|
||||||
|
```
|
||||||
|
|
||||||
|
There is also a specialization for `vk::SwapchainKHR` which takes an additional argument to specify a surface:
|
||||||
|
|
||||||
|
```c++
|
||||||
|
vk::SwapchainKHR swapchain = device.createSwapchainKHR(...);
|
||||||
|
vk::SharedSwapchainKHR sharedSwapchain(swapchain, device, surface); // sharedSwapchain now owns the swapchain and surface
|
||||||
|
```
|
||||||
|
|
||||||
|
You can create a `vk::SharedHandle` overload for your own handle type or own shared handles by providing several template arguments to SharedHandleBase:
|
||||||
|
- A handle type
|
||||||
|
- A parent handle type or a header structure, that contains parent
|
||||||
|
- A class itself for CRTP
|
||||||
|
|
||||||
|
With this, provide a custom static destruction function `internalDestroy`, that takes in a parent handle and a handle to destroy. Don't forget to add a friend declaration for the base class.
|
||||||
|
|
||||||
|
```c++
|
||||||
|
// Example of a custom shared device, that takes in an instance as a parent
|
||||||
|
class shared_handle<VkDevice> : public vk::SharedHandleBase<VkDevice, vk::SharedInstance, shared_handle<VkDevice>>
|
||||||
|
{
|
||||||
|
using base = vk::SharedHandleBase<VkDevice, vk::SharedInstance, shared_handle<VkDevice>>;
|
||||||
|
friend base;
|
||||||
|
|
||||||
|
public:
|
||||||
|
shared_handle() = default;
|
||||||
|
explicit shared_handle(VkDevice handle, vk::SharedInstance parent) noexcept
|
||||||
|
: base(handle, std::move(parent)) {}
|
||||||
|
|
||||||
|
const auto& getParent() const noexcept {
|
||||||
|
return getHeader();
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
static void internalDestroy(const vk::SharedInstance& /*control*/, VkDevice handle) noexcept {
|
||||||
|
vkDestroyDevice(handle);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
```
|
||||||
|
|
||||||
|
The API will be extended to provide creation functions in the future.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
### Custom allocators
|
### Custom allocators
|
||||||
|
|
||||||
Sometimes it is required to use `std::vector` with custom allocators. Vulkan-Hpp supports vectors with custom allocators as input for `vk::ArrayProxy` and for functions which do return a vector. For the latter case, add your favorite custom allocator as template argument to the function call like this:
|
Sometimes it is required to use `std::vector` with custom allocators. Vulkan-Hpp supports vectors with custom allocators as input for `vk::ArrayProxy` and for functions which do return a vector. For the latter case, add your favorite custom allocator as template argument to the function call like this:
|
||||||
|
|||||||
@ -390,11 +390,13 @@ typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool
|
|||||||
)";
|
)";
|
||||||
|
|
||||||
std::string str = replaceWithMap( vulkanHandlesHppTemplate,
|
std::string str = replaceWithMap( vulkanHandlesHppTemplate,
|
||||||
{ { "handles", generateHandles() },
|
{
|
||||||
|
{ "handles", generateHandles() },
|
||||||
{ "handleForwardDeclarations", generateHandleForwardDeclarations() },
|
{ "handleForwardDeclarations", generateHandleForwardDeclarations() },
|
||||||
{ "licenseHeader", m_vulkanLicenseHeader },
|
{ "licenseHeader", m_vulkanLicenseHeader },
|
||||||
{ "structForwardDeclarations", generateStructForwardDeclarations() },
|
{ "structForwardDeclarations", generateStructForwardDeclarations() },
|
||||||
{ "uniqueHandles", generateUniqueHandles() } } );
|
{ "uniqueHandles", generateUniqueHandles() },
|
||||||
|
} );
|
||||||
|
|
||||||
writeToFile( str, vulkan_handles_hpp );
|
writeToFile( str, vulkan_handles_hpp );
|
||||||
}
|
}
|
||||||
@ -510,6 +512,7 @@ ${constexprDefines}
|
|||||||
#include <vulkan/${api}_funcs.hpp>
|
#include <vulkan/${api}_funcs.hpp>
|
||||||
// clang-format on
|
// clang-format on
|
||||||
|
|
||||||
|
|
||||||
namespace VULKAN_HPP_NAMESPACE
|
namespace VULKAN_HPP_NAMESPACE
|
||||||
{
|
{
|
||||||
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
|
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
|
||||||
@ -630,6 +633,46 @@ ${RAIICommandDefinitions}
|
|||||||
writeToFile( str, vulkan_raii_hpp );
|
writeToFile( str, vulkan_raii_hpp );
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void VulkanHppGenerator::generateSharedHppFile() const
|
||||||
|
{
|
||||||
|
std::string const vulkan_shared_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_shared.hpp";
|
||||||
|
std::cout << "VulkanHppGenerator: Generating " << vulkan_shared_hpp << " ..." << std::endl;
|
||||||
|
|
||||||
|
std::string const vulkanHandlesHppTemplate = R"(${licenseHeader}
|
||||||
|
#ifndef VULKAN_SHARED_HPP
|
||||||
|
#define VULKAN_SHARED_HPP
|
||||||
|
|
||||||
|
#include <vulkan/${api}.hpp>
|
||||||
|
#include <atomic> // std::atomic_size_t
|
||||||
|
|
||||||
|
|
||||||
|
namespace VULKAN_HPP_NAMESPACE
|
||||||
|
{
|
||||||
|
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
||||||
|
${sharedHandle}
|
||||||
|
${sharedDestroy}
|
||||||
|
${sharedHandles}
|
||||||
|
${sharedHandleSpecializations}
|
||||||
|
${sharedHandlesNoDestroy}
|
||||||
|
#endif // !VULKAN_HPP_NO_SMART_HANDLE
|
||||||
|
} // namespace VULKAN_HPP_NAMESPACE
|
||||||
|
#endif // VULKAN_SHARED_HPP
|
||||||
|
)";
|
||||||
|
|
||||||
|
std::string str = replaceWithMap( vulkanHandlesHppTemplate,
|
||||||
|
{
|
||||||
|
{ "api", m_api },
|
||||||
|
{ "licenseHeader", m_vulkanLicenseHeader },
|
||||||
|
{ "sharedDestroy", readSnippet( "SharedDestroy.hpp" ) },
|
||||||
|
{ "sharedHandle", readSnippet( "SharedHandle.hpp" ) },
|
||||||
|
{ "sharedHandles", generateSharedHandles() },
|
||||||
|
{ "sharedHandlesNoDestroy", generateSharedHandlesNoDestroy() },
|
||||||
|
{ "sharedHandleSpecializations", readSnippet( "SharedHandleSpecializations.hpp" ) },
|
||||||
|
} );
|
||||||
|
|
||||||
|
writeToFile( str, vulkan_shared_hpp );
|
||||||
|
}
|
||||||
|
|
||||||
void VulkanHppGenerator::generateStaticAssertionsHppFile() const
|
void VulkanHppGenerator::generateStaticAssertionsHppFile() const
|
||||||
{
|
{
|
||||||
std::string const static_assertions_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_static_assertions.hpp";
|
std::string const static_assertions_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_static_assertions.hpp";
|
||||||
@ -5064,6 +5107,53 @@ std::string VulkanHppGenerator::generateCppModuleStructUsings() const
|
|||||||
return structUsings;
|
return structUsings;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
std::string VulkanHppGenerator::generateCppModuleSharedHandleUsings() const
|
||||||
|
{
|
||||||
|
auto const usingTemplate = std::string{ R"( using VULKAN_HPP_NAMESPACE::Shared${handleName};
|
||||||
|
)" };
|
||||||
|
auto sharedHandleUsings = std::string{ R"(
|
||||||
|
//======================
|
||||||
|
//=== SHARED HANDLEs ===
|
||||||
|
//======================
|
||||||
|
)" };
|
||||||
|
auto const [smartHandleEnter, smartHandleLeave] = generateProtection( "VULKAN_HPP_NO_SMART_HANDLE", false );
|
||||||
|
|
||||||
|
sharedHandleUsings += "\n" + smartHandleEnter;
|
||||||
|
|
||||||
|
auto const generateUsingsAndProtection = [&usingTemplate, this]( std::vector<RequireData> const & requireData, std::string const & title )
|
||||||
|
{
|
||||||
|
auto usings = std::string{};
|
||||||
|
for ( auto const & require : requireData )
|
||||||
|
{
|
||||||
|
for ( auto const & type : require.types )
|
||||||
|
{
|
||||||
|
if ( auto const & handleIt = m_handles.find( type ); handleIt != m_handles.end() )
|
||||||
|
{
|
||||||
|
usings += replaceWithMap( usingTemplate, { { "handleName", stripPrefix( handleIt->first, "Vk" ) } } );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return addTitleAndProtection( title, usings );
|
||||||
|
};
|
||||||
|
|
||||||
|
for ( auto const & feature : m_features )
|
||||||
|
{
|
||||||
|
sharedHandleUsings += generateUsingsAndProtection( feature.requireData, feature.name );
|
||||||
|
}
|
||||||
|
|
||||||
|
for ( auto const & extension : m_extensions )
|
||||||
|
{
|
||||||
|
sharedHandleUsings += generateUsingsAndProtection( extension.requireData, extension.name );
|
||||||
|
}
|
||||||
|
|
||||||
|
sharedHandleUsings += R"( using VULKAN_HPP_NAMESPACE::SharedHandleTraits;
|
||||||
|
)";
|
||||||
|
|
||||||
|
sharedHandleUsings += smartHandleLeave + "\n";
|
||||||
|
|
||||||
|
return sharedHandleUsings;
|
||||||
|
}
|
||||||
|
|
||||||
std::string VulkanHppGenerator::generateCppModuleUniqueHandleUsings() const
|
std::string VulkanHppGenerator::generateCppModuleUniqueHandleUsings() const
|
||||||
{
|
{
|
||||||
auto const usingTemplate = std::string{ R"( using VULKAN_HPP_NAMESPACE::Unique${handleName};
|
auto const usingTemplate = std::string{ R"( using VULKAN_HPP_NAMESPACE::Unique${handleName};
|
||||||
@ -5268,8 +5358,9 @@ std::string VulkanHppGenerator::generateCppModuleUsings() const
|
|||||||
|
|
||||||
auto const hardCodedTypes = std::array{ "ArrayWrapper1D", "ArrayWrapper2D", "FlagTraits", "Flags", "DispatchLoaderBase", "DispatchLoaderDynamic" };
|
auto const hardCodedTypes = std::array{ "ArrayWrapper1D", "ArrayWrapper2D", "FlagTraits", "Flags", "DispatchLoaderBase", "DispatchLoaderDynamic" };
|
||||||
auto const hardCodedEnhancedModeTypes =
|
auto const hardCodedEnhancedModeTypes =
|
||||||
std::array{ "ArrayProxy", "ArrayProxyNoTemporaries", "StridedArrayProxy", "Optional", "StructureChain", "UniqueHandle" };
|
std::array{ "ArrayProxy", "ArrayProxyNoTemporaries", "StridedArrayProxy", "Optional", "StructureChain", "UniqueHandle", "SharedHandle" };
|
||||||
auto const hardCodedSmartHandleTypes = std::array{ "ObjectDestroy", "ObjectFree", "ObjectRelease", "PoolFree" };
|
auto const hardCodedSmartHandleTypes = std::array{ "ObjectDestroy", "ObjectFree", "ObjectRelease", "PoolFree",
|
||||||
|
"ObjectDestroyShared", "ObjectFreeShared", "ObjectReleaseShared", "PoolFreeShared" };
|
||||||
|
|
||||||
auto usings = std::string{ R"( //=====================================
|
auto usings = std::string{ R"( //=====================================
|
||||||
//=== HARDCODED TYPEs AND FUNCTIONs ===
|
//=== HARDCODED TYPEs AND FUNCTIONs ===
|
||||||
@ -5401,6 +5492,7 @@ std::string VulkanHppGenerator::generateCppModuleUsings() const
|
|||||||
usings += generateCppModuleStructUsings();
|
usings += generateCppModuleStructUsings();
|
||||||
usings += generateCppModuleHandleUsings();
|
usings += generateCppModuleHandleUsings();
|
||||||
usings += generateCppModuleUniqueHandleUsings();
|
usings += generateCppModuleUniqueHandleUsings();
|
||||||
|
usings += generateCppModuleSharedHandleUsings();
|
||||||
usings += generateCppModuleFuncsUsings();
|
usings += generateCppModuleFuncsUsings();
|
||||||
|
|
||||||
auto const [enterDisableEnhanced, leaveDisableEnhanced] = generateProtection( "VULKAN_HPP_DISABLE_ENHANCED_MODE", false );
|
auto const [enterDisableEnhanced, leaveDisableEnhanced] = generateProtection( "VULKAN_HPP_DISABLE_ENHANCED_MODE", false );
|
||||||
@ -11624,7 +11716,7 @@ ${aliasHandle})";
|
|||||||
return replaceWithMap( uniqueHandleTemplate,
|
return replaceWithMap( uniqueHandleTemplate,
|
||||||
{ { "aliasHandle", aliasHandle },
|
{ { "aliasHandle", aliasHandle },
|
||||||
{ "deleterAction", ( handleData.second.deleteCommand.substr( 2, 4 ) == "Free" ) ? "Free" : "Destroy" },
|
{ "deleterAction", ( handleData.second.deleteCommand.substr( 2, 4 ) == "Free" ) ? "Free" : "Destroy" },
|
||||||
{ "deleterParent", handleData.second.deleteParent.empty() ? "NoParent" : stripPrefix( handleData.second.deleteParent, "Vk" ) },
|
{ "deleterParent", handleData.second.destructorType.empty() ? "NoParent" : stripPrefix( handleData.second.destructorType, "Vk" ) },
|
||||||
{ "deleterPool", handleData.second.deletePool.empty() ? "" : ", " + stripPrefix( handleData.second.deletePool, "Vk" ) },
|
{ "deleterPool", handleData.second.deletePool.empty() ? "" : ", " + stripPrefix( handleData.second.deletePool, "Vk" ) },
|
||||||
{ "deleterType", handleData.second.deletePool.empty() ? "Object" : "Pool" },
|
{ "deleterType", handleData.second.deletePool.empty() ? "Object" : "Pool" },
|
||||||
{ "type", type } } );
|
{ "type", type } } );
|
||||||
@ -11675,6 +11767,150 @@ ${uniqueHandles}
|
|||||||
return replaceWithMap( uniqueHandlesTemplate, { { "uniqueHandles", uniqueHandles } } );
|
return replaceWithMap( uniqueHandlesTemplate, { { "uniqueHandles", uniqueHandles } } );
|
||||||
}
|
}
|
||||||
|
|
||||||
|
std::string VulkanHppGenerator::generateSharedHandle( std::pair<std::string, HandleData> const & handleData ) const
|
||||||
|
{
|
||||||
|
if ( !handleData.second.deleteCommand.empty() )
|
||||||
|
{
|
||||||
|
std::string type = stripPrefix( handleData.first, "Vk" );
|
||||||
|
std::string aliasHandle;
|
||||||
|
auto aliasIt = findAlias( handleData.first, m_handleAliases );
|
||||||
|
if ( aliasIt != m_handleAliases.end() )
|
||||||
|
{
|
||||||
|
static const std::string aliasHandleTemplate = R"( using Shared${aliasType} = SharedHandle<${type}>;)";
|
||||||
|
|
||||||
|
aliasHandle += replaceWithMap( aliasHandleTemplate, { { "aliasType", stripPrefix( aliasIt->first, "Vk" ) }, { "type", type } } );
|
||||||
|
}
|
||||||
|
|
||||||
|
static const std::string sharedHandleTemplate = R"( template <>
|
||||||
|
class SharedHandleTraits<${type}>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = ${destructor};
|
||||||
|
using deleter = ${deleterType}${deleterAction}Shared<${type}${deleterPool}>;
|
||||||
|
};
|
||||||
|
using Shared${type} = SharedHandle<${type}>;
|
||||||
|
${aliasHandle})";
|
||||||
|
|
||||||
|
return replaceWithMap( sharedHandleTemplate,
|
||||||
|
{ { "aliasHandle", aliasHandle },
|
||||||
|
{ "deleterAction", ( handleData.second.deleteCommand.substr( 2, 4 ) == "Free" ) ? "Free" : "Destroy" },
|
||||||
|
{ "deleterPool", handleData.second.deletePool.empty() ? "" : ", " + stripPrefix( handleData.second.deletePool, "Vk" ) },
|
||||||
|
{ "deleterType", handleData.second.deletePool.empty() ? "Object" : "Pool" },
|
||||||
|
{ "destructor", handleData.second.destructorType.empty() ? "NoDestructor" : stripPrefix( handleData.second.destructorType, "Vk" ) },
|
||||||
|
{ "type", type } } );
|
||||||
|
}
|
||||||
|
return "";
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string VulkanHppGenerator::generateSharedHandleNoDestroy( std::pair<std::string, HandleData> const & handleData ) const
|
||||||
|
{
|
||||||
|
if ( handleData.second.deleteCommand.empty() )
|
||||||
|
{
|
||||||
|
std::string type = stripPrefix( handleData.first, "Vk" );
|
||||||
|
std::string aliasHandle;
|
||||||
|
auto aliasIt = findAlias( handleData.first, m_handleAliases );
|
||||||
|
if ( aliasIt != m_handleAliases.end() )
|
||||||
|
{
|
||||||
|
static const std::string aliasHandleTemplate = R"( using Shared${aliasType} = SharedHandle<${type}>;)";
|
||||||
|
|
||||||
|
aliasHandle += replaceWithMap( aliasHandleTemplate, { { "aliasType", stripPrefix( aliasIt->first, "Vk" ) }, { "type", type } } );
|
||||||
|
}
|
||||||
|
|
||||||
|
static const std::string sharedHandleTemplate = R"(
|
||||||
|
template <>
|
||||||
|
class SharedHandle<${type}> : public SharedHandleBaseNoDestroy<${type}, ${parent}>
|
||||||
|
{
|
||||||
|
friend SharedHandleBase<${type}, ${parent}>;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
explicit SharedHandle(${type} handle, ${parent} parent) noexcept
|
||||||
|
: SharedHandleBaseNoDestroy<${type}, ${parent}>(handle, std::move(parent))
|
||||||
|
{}
|
||||||
|
};
|
||||||
|
using Shared${type} = SharedHandle<${type}>;
|
||||||
|
${aliasHandle})";
|
||||||
|
|
||||||
|
return replaceWithMap( sharedHandleTemplate,
|
||||||
|
{ { "aliasHandle", aliasHandle }, { "parent", "Shared" + stripPrefix( handleData.second.parent, "Vk" ) }, { "type", type } } );
|
||||||
|
}
|
||||||
|
return "";
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string VulkanHppGenerator::generateSharedHandle( std::vector<RequireData> const & requireData, std::string const & title ) const
|
||||||
|
{
|
||||||
|
std::string str;
|
||||||
|
for ( auto const & require : requireData )
|
||||||
|
{
|
||||||
|
for ( auto const & type : require.types )
|
||||||
|
{
|
||||||
|
auto handleIt = m_handles.find( type );
|
||||||
|
if ( handleIt != m_handles.end() )
|
||||||
|
{
|
||||||
|
str += generateSharedHandle( *handleIt );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return addTitleAndProtection( title, str );
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string VulkanHppGenerator::generateSharedHandleNoDestroy( std::vector<RequireData> const & requireData, std::string const & title ) const
|
||||||
|
{
|
||||||
|
std::string str;
|
||||||
|
for ( auto const & require : requireData )
|
||||||
|
{
|
||||||
|
for ( auto const & type : require.types )
|
||||||
|
{
|
||||||
|
auto handleIt = m_handles.find( type );
|
||||||
|
if ( handleIt != m_handles.end() )
|
||||||
|
{
|
||||||
|
str += generateSharedHandleNoDestroy( *handleIt );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return addTitleAndProtection( title, str );
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string VulkanHppGenerator::generateSharedHandlesNoDestroy() const
|
||||||
|
{
|
||||||
|
std::string sharedHandles;
|
||||||
|
for ( auto const & feature : m_features )
|
||||||
|
{
|
||||||
|
sharedHandles += generateSharedHandleNoDestroy( feature.requireData, feature.name );
|
||||||
|
}
|
||||||
|
for ( auto const & extension : m_extensions )
|
||||||
|
{
|
||||||
|
sharedHandles += generateSharedHandleNoDestroy( extension.requireData, extension.name );
|
||||||
|
}
|
||||||
|
assert( sharedHandles.back() == '\n' );
|
||||||
|
sharedHandles.pop_back();
|
||||||
|
return sharedHandles;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string VulkanHppGenerator::generateSharedHandles() const
|
||||||
|
{
|
||||||
|
std::string sharedHandlesTemplate = R"(
|
||||||
|
//======================
|
||||||
|
//=== SHARED HANDLEs ===
|
||||||
|
//======================
|
||||||
|
|
||||||
|
${sharedHandles}
|
||||||
|
)";
|
||||||
|
|
||||||
|
std::string sharedHandles;
|
||||||
|
for ( auto const & feature : m_features )
|
||||||
|
{
|
||||||
|
sharedHandles += generateSharedHandle( feature.requireData, feature.name );
|
||||||
|
}
|
||||||
|
for ( auto const & extension : m_extensions )
|
||||||
|
{
|
||||||
|
sharedHandles += generateSharedHandle( extension.requireData, extension.name );
|
||||||
|
}
|
||||||
|
assert( sharedHandles.back() == '\n' );
|
||||||
|
sharedHandles.pop_back();
|
||||||
|
return replaceWithMap( sharedHandlesTemplate, { { "sharedHandles", sharedHandles } } );
|
||||||
|
}
|
||||||
|
|
||||||
std::string VulkanHppGenerator::generateVectorSizeCheck( std::string const & name,
|
std::string VulkanHppGenerator::generateVectorSizeCheck( std::string const & name,
|
||||||
CommandData const & commandData,
|
CommandData const & commandData,
|
||||||
size_t initialSkipCount,
|
size_t initialSkipCount,
|
||||||
@ -14898,7 +15134,7 @@ void VulkanHppGenerator::registerDeleter( std::string const & commandName, Comma
|
|||||||
auto handleIt = m_handles.find( commandData.params[valueIndex].type.type );
|
auto handleIt = m_handles.find( commandData.params[valueIndex].type.type );
|
||||||
assert( handleIt != m_handles.end() );
|
assert( handleIt != m_handles.end() );
|
||||||
handleIt->second.deleteCommand = commandName;
|
handleIt->second.deleteCommand = commandName;
|
||||||
handleIt->second.deleteParent = key;
|
handleIt->second.destructorType = key;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -15270,6 +15506,7 @@ int main( int argc, char ** argv )
|
|||||||
generator.prepareRAIIHandles();
|
generator.prepareRAIIHandles();
|
||||||
generator.generateMacrosFile();
|
generator.generateMacrosFile();
|
||||||
generator.generateRAIIHppFile();
|
generator.generateRAIIHppFile();
|
||||||
|
generator.generateSharedHppFile();
|
||||||
generator.generateStaticAssertionsHppFile();
|
generator.generateStaticAssertionsHppFile();
|
||||||
generator.generateStructsHppFile();
|
generator.generateStructsHppFile();
|
||||||
generator.generateToStringHppFile();
|
generator.generateToStringHppFile();
|
||||||
|
|||||||
@ -89,6 +89,7 @@ public:
|
|||||||
void generateHppFile() const;
|
void generateHppFile() const;
|
||||||
void generateMacrosFile() const;
|
void generateMacrosFile() const;
|
||||||
void generateRAIIHppFile() const;
|
void generateRAIIHppFile() const;
|
||||||
|
void generateSharedHppFile() const;
|
||||||
void generateStaticAssertionsHppFile() const;
|
void generateStaticAssertionsHppFile() const;
|
||||||
void generateStructsHppFile() const;
|
void generateStructsHppFile() const;
|
||||||
void generateToStringHppFile() const;
|
void generateToStringHppFile() const;
|
||||||
@ -291,8 +292,8 @@ private:
|
|||||||
std::set<std::string> childrenHandles = {};
|
std::set<std::string> childrenHandles = {};
|
||||||
std::set<std::string> commands = {};
|
std::set<std::string> commands = {};
|
||||||
std::string deleteCommand = {};
|
std::string deleteCommand = {};
|
||||||
std::string deleteParent = {};
|
|
||||||
std::string deletePool = {};
|
std::string deletePool = {};
|
||||||
|
std::string destructorType = {};
|
||||||
std::string objTypeEnum = {};
|
std::string objTypeEnum = {};
|
||||||
std::string parent = {};
|
std::string parent = {};
|
||||||
std::set<std::string> secondLevelCommands = {};
|
std::set<std::string> secondLevelCommands = {};
|
||||||
@ -611,6 +612,7 @@ private:
|
|||||||
std::string generateCppModuleExtensionInspectionUsings() const;
|
std::string generateCppModuleExtensionInspectionUsings() const;
|
||||||
std::string generateCppModuleUsings() const;
|
std::string generateCppModuleUsings() const;
|
||||||
std::string generateCppModuleRaiiUsings() const;
|
std::string generateCppModuleRaiiUsings() const;
|
||||||
|
std::string generateCppModuleSharedHandleUsings() const;
|
||||||
std::string generateDataDeclarations( CommandData const & commandData,
|
std::string generateDataDeclarations( CommandData const & commandData,
|
||||||
std::vector<size_t> const & returnParams,
|
std::vector<size_t> const & returnParams,
|
||||||
std::map<size_t, VectorParamData> const & vectorParams,
|
std::map<size_t, VectorParamData> const & vectorParams,
|
||||||
@ -875,6 +877,12 @@ private:
|
|||||||
std::string generateUniqueHandle( std::pair<std::string, HandleData> const & handleData ) const;
|
std::string generateUniqueHandle( std::pair<std::string, HandleData> const & handleData ) const;
|
||||||
std::string generateUniqueHandle( std::vector<RequireData> const & requireData, std::string const & title ) const;
|
std::string generateUniqueHandle( std::vector<RequireData> const & requireData, std::string const & title ) const;
|
||||||
std::string generateUniqueHandles() const;
|
std::string generateUniqueHandles() const;
|
||||||
|
std::string generateSharedHandle( std::pair<std::string, HandleData> const & handleData ) const;
|
||||||
|
std::string generateSharedHandle( std::vector<RequireData> const & requireData, std::string const & title ) const;
|
||||||
|
std::string generateSharedHandleNoDestroy( std::pair<std::string, HandleData> const & handleData ) const;
|
||||||
|
std::string generateSharedHandleNoDestroy( std::vector<RequireData> const & requireData, std::string const & title ) const;
|
||||||
|
std::string generateSharedHandles() const;
|
||||||
|
std::string generateSharedHandlesNoDestroy() const;
|
||||||
std::string generateVectorSizeCheck( std::string const & name,
|
std::string generateVectorSizeCheck( std::string const & name,
|
||||||
CommandData const & commandData,
|
CommandData const & commandData,
|
||||||
size_t initialSkipCount,
|
size_t initialSkipCount,
|
||||||
|
|||||||
@ -57,6 +57,7 @@ add_subdirectory( PipelineDerivative )
|
|||||||
add_subdirectory( PushConstants )
|
add_subdirectory( PushConstants )
|
||||||
add_subdirectory( PushDescriptors )
|
add_subdirectory( PushDescriptors )
|
||||||
add_subdirectory( RayTracing )
|
add_subdirectory( RayTracing )
|
||||||
|
add_subdirectory( SharedHandles )
|
||||||
add_subdirectory( SecondaryCommandBuffer )
|
add_subdirectory( SecondaryCommandBuffer )
|
||||||
add_subdirectory( SeparateImageSampler )
|
add_subdirectory( SeparateImageSampler )
|
||||||
add_subdirectory( SurfaceCapabilities )
|
add_subdirectory( SurfaceCapabilities )
|
||||||
|
|||||||
15
samples/SharedHandles/CMakeLists.txt
Normal file
15
samples/SharedHandles/CMakeLists.txt
Normal file
@ -0,0 +1,15 @@
|
|||||||
|
# Copyright(c) 2019, NVIDIA CORPORATION. All rights reserved.
|
||||||
|
#
|
||||||
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
# you may not use this file except in compliance with the License.
|
||||||
|
# You may obtain a copy of the License at
|
||||||
|
#
|
||||||
|
# http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
#
|
||||||
|
# Unless required by applicable law or agreed to in writing, software
|
||||||
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
# See the License for the specific language governing permissions and
|
||||||
|
# limitations under the License.
|
||||||
|
|
||||||
|
vulkan_hpp__setup_sample_dynamic( NAME SharedHandles )
|
||||||
377
samples/SharedHandles/SharedHandles.cpp
Normal file
377
samples/SharedHandles/SharedHandles.cpp
Normal file
@ -0,0 +1,377 @@
|
|||||||
|
// Copyright(c) 2023, Ilya Doroshenko. All rights reserved.
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
// you may not use this file except in compliance with the License.
|
||||||
|
// You may obtain a copy of the License at
|
||||||
|
//
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
//
|
||||||
|
// Unless required by applicable law or agreed to in writing, software
|
||||||
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
// See the License for the specific language governing permissions and
|
||||||
|
// limitations under the License.
|
||||||
|
//
|
||||||
|
// VulkanHpp Samples : SharedHandles
|
||||||
|
// Draw a textured cube using shared handles for resource management and correct order of destruction
|
||||||
|
|
||||||
|
#include "../utils/geometries.hpp"
|
||||||
|
#include "../utils/math.hpp"
|
||||||
|
#include "../utils/shaders.hpp"
|
||||||
|
#include "../utils/utils.hpp"
|
||||||
|
#include "SPIRV/GlslangToSpv.h"
|
||||||
|
|
||||||
|
#include <iostream>
|
||||||
|
#include <thread>
|
||||||
|
#include <vulkan/vulkan_shared.hpp>
|
||||||
|
|
||||||
|
static char const * AppName = "SharedHandles";
|
||||||
|
static char const * EngineName = "Vulkan.hpp";
|
||||||
|
|
||||||
|
std::vector<vk::SharedFramebuffer> makeSharedFramebuffers( const vk::SharedDevice & device,
|
||||||
|
const vk::SharedRenderPass & renderPass,
|
||||||
|
const std::vector<vk::ImageView> & imageViews,
|
||||||
|
const vk::SharedImageView & depthImageView,
|
||||||
|
const vk::Extent2D & extent )
|
||||||
|
{
|
||||||
|
auto renderPassHandle = renderPass.get(); // lvalue reference is required for the capture below
|
||||||
|
std::vector<vk::SharedFramebuffer> sharedFramebuffers;
|
||||||
|
std::vector<vk::Framebuffer> framebuffers = vk::su::createFramebuffers( device.get(), renderPassHandle, imageViews, depthImageView.get(), extent );
|
||||||
|
sharedFramebuffers.reserve( framebuffers.size() );
|
||||||
|
for ( auto & framebuffer : framebuffers )
|
||||||
|
{
|
||||||
|
sharedFramebuffers.emplace_back( framebuffer, device );
|
||||||
|
}
|
||||||
|
|
||||||
|
return sharedFramebuffers;
|
||||||
|
}
|
||||||
|
|
||||||
|
class Window
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
Window( const char * windowName, vk::Extent2D extent ) : window( vk::su::createWindow( windowName, extent ) ) {}
|
||||||
|
|
||||||
|
public:
|
||||||
|
vk::su::WindowData window;
|
||||||
|
};
|
||||||
|
|
||||||
|
class Engine
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
Engine( const vk::su::WindowData & window )
|
||||||
|
{
|
||||||
|
instance = vk::SharedInstance{ vk::su::createInstance( AppName, EngineName, {}, vk::su::getInstanceExtensions() ) };
|
||||||
|
#if !defined( NDEBUG )
|
||||||
|
debugUtilsMessenger =
|
||||||
|
vk::SharedDebugUtilsMessengerEXT{ instance->createDebugUtilsMessengerEXT( vk::su::makeDebugUtilsMessengerCreateInfoEXT() ), instance };
|
||||||
|
#endif
|
||||||
|
physicalDevice = instance->enumeratePhysicalDevices().front();
|
||||||
|
|
||||||
|
createDeviceAndSwapChain( window );
|
||||||
|
initialize();
|
||||||
|
}
|
||||||
|
|
||||||
|
void createDeviceAndSwapChain( const vk::su::WindowData & window )
|
||||||
|
{
|
||||||
|
VkSurfaceKHR surface;
|
||||||
|
VkResult err = glfwCreateWindowSurface( static_cast<VkInstance>( instance.get() ), window.handle, nullptr, &surface );
|
||||||
|
if ( err != VK_SUCCESS )
|
||||||
|
throw std::runtime_error( "Failed to create window!" );
|
||||||
|
vk::SharedSurfaceKHR sharedSurface{ surface, instance };
|
||||||
|
|
||||||
|
auto graphicsAndPresentQueueFamilyIndex = vk::su::findGraphicsAndPresentQueueFamilyIndex( physicalDevice, sharedSurface.get() );
|
||||||
|
device = vk::SharedDevice{ vk::su::createDevice( physicalDevice, graphicsAndPresentQueueFamilyIndex.first, vk::su::getDeviceExtensions() ) };
|
||||||
|
|
||||||
|
vk::su::SwapChainData swapChainData( physicalDevice,
|
||||||
|
device.get(),
|
||||||
|
sharedSurface.get(),
|
||||||
|
window.extent,
|
||||||
|
vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eTransferSrc,
|
||||||
|
{},
|
||||||
|
graphicsAndPresentQueueFamilyIndex.first,
|
||||||
|
graphicsAndPresentQueueFamilyIndex.second );
|
||||||
|
swapChain = vk::SharedSwapchainKHR{ swapChainData.swapChain, device, sharedSurface };
|
||||||
|
|
||||||
|
imageViews.reserve( swapChainData.images.size() );
|
||||||
|
images.reserve( swapChainData.images.size() );
|
||||||
|
|
||||||
|
// we don't want to destroy the images, since they are owned by the swapchain,
|
||||||
|
// but for the consistent representation we might want shared textures
|
||||||
|
std::transform( swapChainData.images.begin(),
|
||||||
|
swapChainData.images.end(),
|
||||||
|
std::back_inserter( images ),
|
||||||
|
[this]( vk::Image image ) {
|
||||||
|
return vk::SharedImage{ image, device, vk::SwapchainOwns::yes };
|
||||||
|
} );
|
||||||
|
|
||||||
|
std::transform( swapChainData.imageViews.begin(),
|
||||||
|
swapChainData.imageViews.end(),
|
||||||
|
std::back_inserter( imageViews ),
|
||||||
|
[this]( vk::ImageView imageView ) {
|
||||||
|
return vk::SharedImageView{ imageView, device };
|
||||||
|
} );
|
||||||
|
commandPool =
|
||||||
|
vk::SharedCommandPool{ device->createCommandPool( { vk::CommandPoolCreateFlagBits::eResetCommandBuffer, graphicsAndPresentQueueFamilyIndex.first } ),
|
||||||
|
device };
|
||||||
|
graphicsQueue = vk::SharedQueue{ device->getQueue( graphicsAndPresentQueueFamilyIndex.first, 0 ), device };
|
||||||
|
|
||||||
|
|
||||||
|
presentQueue = vk::SharedQueue{ device->getQueue( graphicsAndPresentQueueFamilyIndex.second, 0 ), device };
|
||||||
|
|
||||||
|
depthFormat = vk::Format::eD16Unorm;
|
||||||
|
vk::su::DepthBufferData depthBufferData( physicalDevice, device.get(), depthFormat, window.extent );
|
||||||
|
depthImage = vk::SharedImage{ depthBufferData.image, device };
|
||||||
|
depthImageView = vk::SharedImageView{ depthBufferData.imageView, device };
|
||||||
|
depthMemory = vk::SharedDeviceMemory{ depthBufferData.deviceMemory, device };
|
||||||
|
|
||||||
|
renderPass =
|
||||||
|
vk::SharedRenderPass{ vk::su::createRenderPass( device.get(),
|
||||||
|
vk::su::pickSurfaceFormat( physicalDevice.getSurfaceFormatsKHR( swapChain.getSurface().get() ) ).format,
|
||||||
|
depthFormat ),
|
||||||
|
device };
|
||||||
|
|
||||||
|
framebuffers = makeSharedFramebuffers( device, renderPass, swapChainData.imageViews, depthImageView, window.extent );
|
||||||
|
imageAcquiredSemaphore = vk::SharedSemaphore{ device->createSemaphore( vk::SemaphoreCreateInfo() ), device };
|
||||||
|
drawFence = vk::SharedFence{ device->createFence( vk::FenceCreateInfo() ), device };
|
||||||
|
// We don't need to explicitly keep sharedSurface anymore, it is owned by swapChain now.
|
||||||
|
}
|
||||||
|
|
||||||
|
void initialize()
|
||||||
|
{
|
||||||
|
commandBuffer = vk::SharedCommandBuffer{
|
||||||
|
device->allocateCommandBuffers( vk::CommandBufferAllocateInfo( commandPool.get(), vk::CommandBufferLevel::ePrimary, 1 ) ).front(), device, commandPool
|
||||||
|
};
|
||||||
|
|
||||||
|
auto device_handle = device.get();
|
||||||
|
descriptorSetLayout = vk::SharedDescriptorSetLayout{ vk::su::createDescriptorSetLayout(
|
||||||
|
device_handle,
|
||||||
|
{ { vk::DescriptorType::eUniformBuffer, 1, vk::ShaderStageFlagBits::eVertex },
|
||||||
|
{ vk::DescriptorType::eCombinedImageSampler, 1, vk::ShaderStageFlagBits::eFragment } } ),
|
||||||
|
device };
|
||||||
|
|
||||||
|
auto dsl = descriptorSetLayout.get();
|
||||||
|
|
||||||
|
pipelineLayout = vk::SharedPipelineLayout{ device->createPipelineLayout( vk::PipelineLayoutCreateInfo( vk::PipelineLayoutCreateFlags(), dsl ) ), device };
|
||||||
|
|
||||||
|
glslang::InitializeProcess();
|
||||||
|
vertexShaderModule = vk::SharedShaderModule{ vk::su::createShaderModule( device_handle, vk::ShaderStageFlagBits::eVertex, vertexShaderText_PT_T ), device };
|
||||||
|
fragmentShaderModule =
|
||||||
|
vk::SharedShaderModule{ vk::su::createShaderModule( device_handle, vk::ShaderStageFlagBits::eFragment, fragmentShaderText_T_C ), device };
|
||||||
|
glslang::FinalizeProcess();
|
||||||
|
|
||||||
|
descriptorPool = vk::SharedDescriptorPool{
|
||||||
|
vk::su::createDescriptorPool( device_handle, { { vk::DescriptorType::eUniformBuffer, 1 }, { vk::DescriptorType::eCombinedImageSampler, 1 } } ), device
|
||||||
|
};
|
||||||
|
|
||||||
|
descriptorSetAllocateInfo = vk::DescriptorSetAllocateInfo( descriptorPool.get(), dsl );
|
||||||
|
descriptorSet = vk::SharedDescriptorSet{ device->allocateDescriptorSets( descriptorSetAllocateInfo ).front(), device, descriptorPool };
|
||||||
|
|
||||||
|
pipelineCache = vk::SharedPipelineCache{ device->createPipelineCache( vk::PipelineCacheCreateInfo() ), device };
|
||||||
|
graphicsPipeline = vk::SharedPipeline{ vk::su::createGraphicsPipeline( device_handle,
|
||||||
|
pipelineCache.get(),
|
||||||
|
std::make_pair( vertexShaderModule.get(), nullptr ),
|
||||||
|
std::make_pair( fragmentShaderModule.get(), nullptr ),
|
||||||
|
sizeof( texturedCubeData[0] ),
|
||||||
|
{ { vk::Format::eR32G32B32A32Sfloat, 0 }, { vk::Format::eR32G32Sfloat, 16 } },
|
||||||
|
vk::FrontFace::eClockwise,
|
||||||
|
true,
|
||||||
|
pipelineLayout.get(),
|
||||||
|
renderPass.get() ),
|
||||||
|
device };
|
||||||
|
|
||||||
|
// Get the index of the next available swapchain image:
|
||||||
|
vk::ResultValue<uint32_t> currentBufferR = device->acquireNextImageKHR( swapChain.get(), vk::su::FenceTimeout, imageAcquiredSemaphore.get(), nullptr );
|
||||||
|
assert( currentBufferR.result == vk::Result::eSuccess );
|
||||||
|
assert( currentBufferR.value < framebuffers.size() );
|
||||||
|
currentBuffer = currentBufferR.value;
|
||||||
|
}
|
||||||
|
|
||||||
|
void beginFrame( vk::Extent2D extent )
|
||||||
|
{
|
||||||
|
std::array<vk::ClearValue, 2> clearValues;
|
||||||
|
clearValues[0].color = vk::ClearColorValue( 0.2f, 0.2f, 0.2f, 0.2f );
|
||||||
|
clearValues[1].depthStencil = vk::ClearDepthStencilValue( 1.0f, 0 );
|
||||||
|
vk::RenderPassBeginInfo renderPassBeginInfo( renderPass.get(), framebuffers[currentBuffer].get(), vk::Rect2D( vk::Offset2D( 0, 0 ), extent ), clearValues );
|
||||||
|
|
||||||
|
commandBuffer->begin( vk::CommandBufferBeginInfo() );
|
||||||
|
commandBuffer->beginRenderPass( renderPassBeginInfo, vk::SubpassContents::eInline );
|
||||||
|
commandBuffer->bindPipeline( vk::PipelineBindPoint::eGraphics, graphicsPipeline.get() );
|
||||||
|
commandBuffer->bindDescriptorSets( vk::PipelineBindPoint::eGraphics, pipelineLayout.get(), 0, descriptorSet.get(), nullptr );
|
||||||
|
|
||||||
|
commandBuffer->setViewport( 0, vk::Viewport( 0.0f, 0.0f, static_cast<float>( extent.width ), static_cast<float>( extent.height ), 0.0f, 1.0f ) );
|
||||||
|
commandBuffer->setScissor( 0, vk::Rect2D( vk::Offset2D( 0, 0 ), extent ) );
|
||||||
|
}
|
||||||
|
|
||||||
|
void endFrame()
|
||||||
|
{
|
||||||
|
commandBuffer->endRenderPass();
|
||||||
|
commandBuffer->end();
|
||||||
|
|
||||||
|
vk::PipelineStageFlags waitDestinationStageMask( vk::PipelineStageFlagBits::eColorAttachmentOutput );
|
||||||
|
|
||||||
|
auto ias = imageAcquiredSemaphore.get();
|
||||||
|
auto comBuf = commandBuffer.get();
|
||||||
|
|
||||||
|
vk::SubmitInfo submitInfo( ias, waitDestinationStageMask, comBuf );
|
||||||
|
graphicsQueue->submit( submitInfo, drawFence.get() );
|
||||||
|
|
||||||
|
while ( vk::Result::eTimeout == device->waitForFences( drawFence.get(), VK_TRUE, vk::su::FenceTimeout ) )
|
||||||
|
;
|
||||||
|
|
||||||
|
auto swap = swapChain.get();
|
||||||
|
vk::Result result = presentQueue->presentKHR( vk::PresentInfoKHR( {}, swap, currentBuffer ) );
|
||||||
|
switch ( result )
|
||||||
|
{
|
||||||
|
case vk::Result::eSuccess: break;
|
||||||
|
case vk::Result::eSuboptimalKHR: std::cout << "vk::Queue::presentKHR returned vk::Result::eSuboptimalKHR !\n"; break;
|
||||||
|
default: assert( false ); // an unexpected result is returned !
|
||||||
|
}
|
||||||
|
std::this_thread::sleep_for( std::chrono::milliseconds( 1000 ) );
|
||||||
|
|
||||||
|
/* VULKAN_KEY_END */
|
||||||
|
device->waitIdle();
|
||||||
|
}
|
||||||
|
|
||||||
|
public:
|
||||||
|
vk::SharedSwapchainKHR swapChain; // swapchain owns surface, that owns Instance, which should be destroyed last
|
||||||
|
vk::PhysicalDevice physicalDevice; // physical device does not have a shared handle since it is not destroyed
|
||||||
|
vk::SharedDevice device;
|
||||||
|
vk::SharedInstance instance; // we don't need to keep the instance, this is just for convenience
|
||||||
|
vk::SharedDebugUtilsMessengerEXT debugUtilsMessenger;
|
||||||
|
|
||||||
|
std::vector<vk::SharedImageView> imageViews;
|
||||||
|
std::vector<vk::SharedImage> images;
|
||||||
|
|
||||||
|
uint32_t currentBuffer = 0;
|
||||||
|
vk::SharedSemaphore imageAcquiredSemaphore;
|
||||||
|
|
||||||
|
// memory still needs to be before the resources that use it in order to get a proper destruction sequence.
|
||||||
|
vk::SharedDeviceMemory depthMemory;
|
||||||
|
vk::SharedImage depthImage;
|
||||||
|
vk::SharedImageView depthImageView;
|
||||||
|
vk::Format depthFormat;
|
||||||
|
|
||||||
|
vk::SharedCommandPool commandPool;
|
||||||
|
vk::SharedCommandBuffer commandBuffer;
|
||||||
|
|
||||||
|
vk::SharedQueue graphicsQueue; // queue is not destroyed, shared handle is purely for consistency
|
||||||
|
vk::SharedQueue presentQueue;
|
||||||
|
|
||||||
|
vk::SharedPipelineCache pipelineCache;
|
||||||
|
vk::SharedPipelineLayout pipelineLayout;
|
||||||
|
vk::SharedRenderPass renderPass;
|
||||||
|
vk::SharedPipeline graphicsPipeline;
|
||||||
|
vk::SharedDescriptorPool descriptorPool;
|
||||||
|
vk::DescriptorSetAllocateInfo descriptorSetAllocateInfo;
|
||||||
|
vk::SharedDescriptorSet descriptorSet;
|
||||||
|
vk::SharedDescriptorSetLayout descriptorSetLayout;
|
||||||
|
|
||||||
|
vk::SharedShaderModule vertexShaderModule;
|
||||||
|
vk::SharedShaderModule fragmentShaderModule;
|
||||||
|
|
||||||
|
std::vector<vk::SharedFramebuffer> framebuffers;
|
||||||
|
|
||||||
|
vk::SharedFence drawFence;
|
||||||
|
};
|
||||||
|
|
||||||
|
class Asset
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
Asset( const Engine & engine, vk::Extent2D extent )
|
||||||
|
{
|
||||||
|
auto device_handle = engine.device.get();
|
||||||
|
vk::su::BufferData vertexBufferData( engine.physicalDevice, device_handle, sizeof( texturedCubeData ), vk::BufferUsageFlagBits::eVertexBuffer );
|
||||||
|
vk::su::copyToDevice( device_handle, vertexBufferData.deviceMemory, texturedCubeData, sizeof( texturedCubeData ) / sizeof( texturedCubeData[0] ) );
|
||||||
|
|
||||||
|
vertexBuffer = vk::SharedBuffer{ vertexBufferData.buffer, engine.device };
|
||||||
|
vertexBufferMemory = vk::SharedDeviceMemory{ vertexBufferData.deviceMemory, engine.device };
|
||||||
|
|
||||||
|
engine.commandBuffer->begin( vk::CommandBufferBeginInfo() );
|
||||||
|
|
||||||
|
vk::su::BufferData uniformBufferData( engine.physicalDevice, device_handle, sizeof( glm::mat4x4 ), vk::BufferUsageFlagBits::eUniformBuffer );
|
||||||
|
glm::mat4x4 mvpcMatrix = vk::su::createModelViewProjectionClipMatrix( extent );
|
||||||
|
vk::su::copyToDevice( device_handle, uniformBufferData.deviceMemory, mvpcMatrix );
|
||||||
|
|
||||||
|
uniformBufferMemory = vk::SharedDeviceMemory{ uniformBufferData.deviceMemory, engine.device };
|
||||||
|
uniformBuffer = vk::SharedBuffer{ uniformBufferData.buffer, engine.device };
|
||||||
|
|
||||||
|
vk::su::TextureData textureData( engine.physicalDevice, device_handle );
|
||||||
|
textureData.setImage( device_handle, engine.commandBuffer.get(), vk::su::CheckerboardImageGenerator() );
|
||||||
|
|
||||||
|
textureImage = vk::SharedImage{ textureData.imageData->image, engine.device };
|
||||||
|
textureImageMemory = vk::SharedDeviceMemory{ textureData.imageData->deviceMemory, engine.device };
|
||||||
|
textureImageView = vk::SharedImageView{ textureData.imageData->imageView, engine.device };
|
||||||
|
textureSampler = vk::SharedSampler{ textureData.sampler, engine.device };
|
||||||
|
|
||||||
|
vk::su::updateDescriptorSets(
|
||||||
|
device_handle, engine.descriptorSet.get(), { { vk::DescriptorType::eUniformBuffer, uniformBufferData.buffer, VK_WHOLE_SIZE, {} } }, textureData );
|
||||||
|
engine.commandBuffer->end();
|
||||||
|
|
||||||
|
vk::su::submitAndWait( device_handle, engine.graphicsQueue.get(), engine.commandBuffer.get() );
|
||||||
|
}
|
||||||
|
|
||||||
|
void draw( vk::CommandBuffer commandBuffer )
|
||||||
|
{
|
||||||
|
commandBuffer.bindVertexBuffers( 0, vertexBuffer.get(), { 0 } );
|
||||||
|
commandBuffer.draw( 12 * 3, 1, 0, 0 );
|
||||||
|
}
|
||||||
|
|
||||||
|
vk::SharedDeviceMemory vertexBufferMemory;
|
||||||
|
vk::SharedBuffer vertexBuffer;
|
||||||
|
|
||||||
|
vk::SharedDeviceMemory uniformBufferMemory;
|
||||||
|
vk::SharedBuffer uniformBuffer;
|
||||||
|
|
||||||
|
vk::SharedDeviceMemory textureImageMemory;
|
||||||
|
vk::SharedImage textureImage;
|
||||||
|
vk::SharedImageView textureImageView;
|
||||||
|
vk::SharedSampler textureSampler;
|
||||||
|
};
|
||||||
|
|
||||||
|
class Application
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
Application() : window( AppName, vk::Extent2D( 500, 500 ) ), engine( window.window ), asset( engine, vk::Extent2D( 500, 500 ) ) {}
|
||||||
|
|
||||||
|
void renderFrame()
|
||||||
|
{
|
||||||
|
engine.beginFrame( vk::Extent2D( 500, 500 ) );
|
||||||
|
asset.draw( engine.commandBuffer.get() );
|
||||||
|
engine.endFrame();
|
||||||
|
}
|
||||||
|
|
||||||
|
int start()
|
||||||
|
{
|
||||||
|
renderFrame();
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// order of window, engine and asset variables is important !
|
||||||
|
Window window;
|
||||||
|
Engine engine;
|
||||||
|
Asset asset;
|
||||||
|
};
|
||||||
|
|
||||||
|
int main( int /*argc*/, char ** /*argv*/ )
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
return Application{}.start();
|
||||||
|
}
|
||||||
|
catch ( vk::SystemError & err )
|
||||||
|
{
|
||||||
|
std::cout << "vk::SystemError: " << err.what() << std::endl;
|
||||||
|
exit( -1 );
|
||||||
|
}
|
||||||
|
catch ( std::exception & err )
|
||||||
|
{
|
||||||
|
std::cout << "std::exception: " << err.what() << std::endl;
|
||||||
|
exit( -1 );
|
||||||
|
}
|
||||||
|
catch ( ... )
|
||||||
|
{
|
||||||
|
std::cout << "unknown error\n";
|
||||||
|
exit( -1 );
|
||||||
|
}
|
||||||
|
}
|
||||||
150
snippets/SharedDestroy.hpp
Normal file
150
snippets/SharedDestroy.hpp
Normal file
@ -0,0 +1,150 @@
|
|||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
class SharedHandleTraits;
|
||||||
|
|
||||||
|
// Silence the function cast warnings.
|
||||||
|
#if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
|
||||||
|
# pragma GCC diagnostic push
|
||||||
|
# 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 )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
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<DispatchLoaderBase> m_destroy = nullptr;
|
||||||
|
const DispatchLoaderBase * m_dispatch = nullptr;
|
||||||
|
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
class ObjectFreeShared
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
|
||||||
|
|
||||||
|
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<DispatchLoaderBase> m_destroy = nullptr;
|
||||||
|
const DispatchLoaderBase * m_dispatch = nullptr;
|
||||||
|
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
class ObjectReleaseShared
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
|
||||||
|
|
||||||
|
template <class Dispatcher>
|
||||||
|
using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const;
|
||||||
|
|
||||||
|
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 )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
public:
|
||||||
|
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
|
||||||
|
( parent.*m_destroy )( handle, *m_dispatch );
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
DestroyFunctionPointerType<DispatchLoaderBase> m_destroy = nullptr;
|
||||||
|
const DispatchLoaderBase * m_dispatch = nullptr;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType, typename PoolType>
|
||||||
|
class PoolFreeShared
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
|
||||||
|
|
||||||
|
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 );
|
||||||
|
( parent.*m_destroy )( m_pool.get(), 1u, &handle, *m_dispatch );
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
DestroyFunctionPointerType<DispatchLoaderBase> m_destroy = nullptr;
|
||||||
|
const DispatchLoaderBase * m_dispatch = nullptr;
|
||||||
|
SharedHandle<PoolType> m_pool{};
|
||||||
|
};
|
||||||
|
|
||||||
|
#if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
|
||||||
|
# pragma GCC diagnostic pop
|
||||||
|
#endif
|
||||||
247
snippets/SharedHandle.hpp
Normal file
247
snippets/SharedHandle.hpp
Normal file
@ -0,0 +1,247 @@
|
|||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
class SharedHandleTraits;
|
||||||
|
|
||||||
|
class NoDestructor
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType, typename = void>
|
||||||
|
struct HasDestructorType : std::false_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
struct HasDestructorType<HandleType, decltype( (void)typename SharedHandleTraits<HandleType>::DestructorType() )> : std::true_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType, typename Enable = void>
|
||||||
|
struct GetDestructorType
|
||||||
|
{
|
||||||
|
using type = NoDestructor;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
struct GetDestructorType<HandleType, typename std::enable_if<HasDestructorType<HandleType>::value>::type>
|
||||||
|
{
|
||||||
|
using type = typename SharedHandleTraits<HandleType>::DestructorType;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <class HandleType>
|
||||||
|
using DestructorTypeOf = typename GetDestructorType<HandleType>::type;
|
||||||
|
|
||||||
|
template <class HandleType>
|
||||||
|
struct HasDestructor : std::integral_constant<bool, !std::is_same<DestructorTypeOf<HandleType>, NoDestructor>::value>
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
//=====================================================================================================================
|
||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
class SharedHandle;
|
||||||
|
|
||||||
|
template <typename DestructorType, typename Deleter>
|
||||||
|
struct SharedHeader
|
||||||
|
{
|
||||||
|
SharedHeader( SharedHandle<DestructorType> parent, Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
|
||||||
|
: parent( std::move( parent ) )
|
||||||
|
, deleter( std::move( deleter ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
SharedHandle<DestructorType> parent;
|
||||||
|
Deleter deleter;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename Deleter>
|
||||||
|
struct SharedHeader<NoDestructor, Deleter>
|
||||||
|
{
|
||||||
|
SharedHeader( Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {}
|
||||||
|
|
||||||
|
Deleter deleter;
|
||||||
|
};
|
||||||
|
|
||||||
|
//=====================================================================================================================
|
||||||
|
|
||||||
|
template <typename HeaderType>
|
||||||
|
class ReferenceCounter
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
template <typename... Args>
|
||||||
|
ReferenceCounter( Args &&... control_args ) : m_header( std::forward<Args>( control_args )... ){}
|
||||||
|
ReferenceCounter( const ReferenceCounter & ) = delete;
|
||||||
|
ReferenceCounter & operator=( const ReferenceCounter & ) = delete;
|
||||||
|
|
||||||
|
public:
|
||||||
|
size_t addRef() VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
// Relaxed memory order is sufficient since this does not impose any ordering on other operations
|
||||||
|
return m_ref_cnt.fetch_add( 1, std::memory_order_relaxed );
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t release() VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
// A release memory order to ensure that all releases are ordered
|
||||||
|
return m_ref_cnt.fetch_sub( 1, std::memory_order_release );
|
||||||
|
}
|
||||||
|
|
||||||
|
public:
|
||||||
|
std::atomic_size_t m_ref_cnt{ 1 };
|
||||||
|
HeaderType m_header{};
|
||||||
|
};
|
||||||
|
|
||||||
|
//=====================================================================================================================
|
||||||
|
|
||||||
|
template <typename HandleType, typename HeaderType, typename ForwardType = SharedHandle<HandleType>>
|
||||||
|
class SharedHandleBase
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
SharedHandleBase() = default;
|
||||||
|
|
||||||
|
template <typename... Args>
|
||||||
|
SharedHandleBase( HandleType handle, Args &&... control_args )
|
||||||
|
: m_control( new ReferenceCounter<HeaderType>( std::forward<Args>( control_args )... ) ), m_handle( handle )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
SharedHandleBase( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
o.addRef();
|
||||||
|
m_handle = o.m_handle;
|
||||||
|
m_control = o.m_control;
|
||||||
|
}
|
||||||
|
|
||||||
|
SharedHandleBase( SharedHandleBase && o ) VULKAN_HPP_NOEXCEPT
|
||||||
|
: m_control( o.m_control )
|
||||||
|
, m_handle( o.m_handle )
|
||||||
|
{
|
||||||
|
o.m_handle = nullptr;
|
||||||
|
o.m_control = nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
SharedHandleBase & operator=( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
SharedHandleBase( o ).swap( *this );
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
SharedHandleBase & operator=( SharedHandleBase && o ) VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
SharedHandleBase( std::move( o ) ).swap( *this );
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
~SharedHandleBase()
|
||||||
|
{
|
||||||
|
// only this function owns the last reference to the control block
|
||||||
|
// the same principle is used in the default deleter of std::shared_ptr
|
||||||
|
if ( m_control && ( m_control->release() == 1 ) )
|
||||||
|
{
|
||||||
|
// noop in x86, but does thread synchronization in ARM
|
||||||
|
// it is required to ensure that last thread is getting to destroy the control block
|
||||||
|
// by ordering all atomic operations before this fence
|
||||||
|
std::atomic_thread_fence( std::memory_order_acquire );
|
||||||
|
ForwardType::internalDestroy( getHeader(), m_handle );
|
||||||
|
delete m_control;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public:
|
||||||
|
HandleType get() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return m_handle;
|
||||||
|
}
|
||||||
|
|
||||||
|
HandleType operator*() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return m_handle;
|
||||||
|
}
|
||||||
|
|
||||||
|
explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return bool( m_handle );
|
||||||
|
}
|
||||||
|
|
||||||
|
const HandleType * operator->() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return &m_handle;
|
||||||
|
}
|
||||||
|
|
||||||
|
HandleType * operator->() VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return &m_handle;
|
||||||
|
}
|
||||||
|
|
||||||
|
void reset() VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
SharedHandleBase().swap( *this );
|
||||||
|
}
|
||||||
|
|
||||||
|
void swap( SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
std::swap( m_handle, o.m_handle );
|
||||||
|
std::swap( m_control, o.m_control );
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T = HandleType>
|
||||||
|
typename std::enable_if<HasDestructor<T>::value, const SharedHandle<DestructorTypeOf<HandleType>> &>::type getDestructorType() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return getHeader().parent;
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
template <typename T = HandleType>
|
||||||
|
static typename std::enable_if<!HasDestructor<T>::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
control.deleter.destroy( handle );
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T = HandleType>
|
||||||
|
static typename std::enable_if<HasDestructor<T>::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
control.deleter.destroy( control.parent.get(), handle );
|
||||||
|
}
|
||||||
|
|
||||||
|
const HeaderType & getHeader() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return m_control->m_header;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
void addRef() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
if ( m_control )
|
||||||
|
m_control->addRef();
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
ReferenceCounter<HeaderType> * m_control = nullptr;
|
||||||
|
HandleType m_handle{};
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
class SharedHandle : public SharedHandleBase<HandleType, SharedHeader<DestructorTypeOf<HandleType>, typename SharedHandleTraits<HandleType>::deleter>>
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
using BaseType = SharedHandleBase<HandleType, SharedHeader<DestructorTypeOf<HandleType>, typename SharedHandleTraits<HandleType>::deleter>>;
|
||||||
|
using DeleterType = typename SharedHandleTraits<HandleType>::deleter;
|
||||||
|
friend BaseType;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
template <typename T = HandleType, typename = typename std::enable_if<HasDestructor<T>::value>::type>
|
||||||
|
explicit SharedHandle( HandleType handle, SharedHandle<DestructorTypeOf<HandleType>> parent, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
|
||||||
|
: BaseType( handle, std::move( parent ), std::move( deleter ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T = HandleType, typename = typename std::enable_if<!HasDestructor<T>::value>::type>
|
||||||
|
explicit SharedHandle( HandleType handle, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT : BaseType( handle, std::move( deleter ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
using BaseType::internalDestroy;
|
||||||
|
};
|
||||||
108
snippets/SharedHandleSpecializations.hpp
Normal file
108
snippets/SharedHandleSpecializations.hpp
Normal file
@ -0,0 +1,108 @@
|
|||||||
|
|
||||||
|
enum class SwapchainOwns
|
||||||
|
{
|
||||||
|
no,
|
||||||
|
yes,
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ImageHeader : SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>, typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter>
|
||||||
|
{
|
||||||
|
ImageHeader( SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>> parent,
|
||||||
|
typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter deleter = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter(),
|
||||||
|
SwapchainOwns swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
|
||||||
|
: SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>, typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter>( std::move( parent ),
|
||||||
|
std::move( deleter ) )
|
||||||
|
, swapchainOwned( swapchainOwned )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
SwapchainOwns swapchainOwned = SwapchainOwns::no;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<VULKAN_HPP_NAMESPACE::Image> : public SharedHandleBase<VULKAN_HPP_NAMESPACE::Image, ImageHeader>
|
||||||
|
{
|
||||||
|
using BaseType = SharedHandleBase<VULKAN_HPP_NAMESPACE::Image, ImageHeader>;
|
||||||
|
using DeleterType = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter;
|
||||||
|
friend BaseType;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( VULKAN_HPP_NAMESPACE::Image handle,
|
||||||
|
SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>> parent,
|
||||||
|
SwapchainOwns swapchain_owned = SwapchainOwns::no,
|
||||||
|
DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
|
||||||
|
: BaseType( handle, std::move( parent ), std::move( deleter ), swapchain_owned )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
static void internalDestroy( const ImageHeader & control, VULKAN_HPP_NAMESPACE::Image handle ) VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
if ( control.swapchainOwned == SwapchainOwns::no )
|
||||||
|
{
|
||||||
|
control.deleter.destroy( control.parent.get(), handle );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct SwapchainHeader
|
||||||
|
{
|
||||||
|
SwapchainHeader( SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> surface,
|
||||||
|
SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>> parent,
|
||||||
|
typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter deleter =
|
||||||
|
typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter() ) VULKAN_HPP_NOEXCEPT
|
||||||
|
: surface( std::move( surface ) )
|
||||||
|
, parent( std::move( parent ) )
|
||||||
|
, deleter( std::move( deleter ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> surface{};
|
||||||
|
SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>> parent{};
|
||||||
|
typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter deleter{};
|
||||||
|
};
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR> : public SharedHandleBase<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainHeader>
|
||||||
|
{
|
||||||
|
using BaseType = SharedHandleBase<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainHeader>;
|
||||||
|
using DeleterType = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter;
|
||||||
|
friend BaseType;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( VULKAN_HPP_NAMESPACE::SwapchainKHR handle,
|
||||||
|
SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>> parent,
|
||||||
|
SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> surface,
|
||||||
|
DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
|
||||||
|
: BaseType( handle, std::move( surface ), std::move( parent ), std::move( deleter ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
public:
|
||||||
|
const SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> & getSurface() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return getHeader().surface;
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
using BaseType::internalDestroy;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType, typename DestructorType>
|
||||||
|
class SharedHandleBaseNoDestroy : public SharedHandleBase<HandleType, DestructorType>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using SharedHandleBase<HandleType, DestructorType>::SharedHandleBase;
|
||||||
|
|
||||||
|
const DestructorType & getDestructorType() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return SharedHandleBase<HandleType, DestructorType>::getHeader();
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
static void internalDestroy( const DestructorType &, HandleType ) VULKAN_HPP_NOEXCEPT {}
|
||||||
|
};
|
||||||
@ -44,6 +44,7 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||||||
using VULKAN_HPP_NAMESPACE::ArrayProxy;
|
using VULKAN_HPP_NAMESPACE::ArrayProxy;
|
||||||
using VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries;
|
using VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries;
|
||||||
using VULKAN_HPP_NAMESPACE::Optional;
|
using VULKAN_HPP_NAMESPACE::Optional;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedHandle;
|
||||||
using VULKAN_HPP_NAMESPACE::StridedArrayProxy;
|
using VULKAN_HPP_NAMESPACE::StridedArrayProxy;
|
||||||
using VULKAN_HPP_NAMESPACE::StructureChain;
|
using VULKAN_HPP_NAMESPACE::StructureChain;
|
||||||
using VULKAN_HPP_NAMESPACE::UniqueHandle;
|
using VULKAN_HPP_NAMESPACE::UniqueHandle;
|
||||||
@ -51,9 +52,13 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||||||
|
|
||||||
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
||||||
using VULKAN_HPP_NAMESPACE::ObjectDestroy;
|
using VULKAN_HPP_NAMESPACE::ObjectDestroy;
|
||||||
|
using VULKAN_HPP_NAMESPACE::ObjectDestroyShared;
|
||||||
using VULKAN_HPP_NAMESPACE::ObjectFree;
|
using VULKAN_HPP_NAMESPACE::ObjectFree;
|
||||||
|
using VULKAN_HPP_NAMESPACE::ObjectFreeShared;
|
||||||
using VULKAN_HPP_NAMESPACE::ObjectRelease;
|
using VULKAN_HPP_NAMESPACE::ObjectRelease;
|
||||||
|
using VULKAN_HPP_NAMESPACE::ObjectReleaseShared;
|
||||||
using VULKAN_HPP_NAMESPACE::PoolFree;
|
using VULKAN_HPP_NAMESPACE::PoolFree;
|
||||||
|
using VULKAN_HPP_NAMESPACE::PoolFreeShared;
|
||||||
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
|
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
|
||||||
|
|
||||||
//==================
|
//==================
|
||||||
@ -2870,6 +2875,104 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||||||
using VULKAN_HPP_NAMESPACE::UniqueShaderEXT;
|
using VULKAN_HPP_NAMESPACE::UniqueShaderEXT;
|
||||||
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
|
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
|
||||||
|
|
||||||
|
//======================
|
||||||
|
//=== SHARED HANDLEs ===
|
||||||
|
//======================
|
||||||
|
|
||||||
|
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
||||||
|
|
||||||
|
//=== VK_VERSION_1_0 ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedBuffer;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedBufferView;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedCommandBuffer;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedCommandPool;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDescriptorPool;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDescriptorSet;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDescriptorSetLayout;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDevice;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDeviceMemory;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedEvent;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedFence;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedFramebuffer;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedImage;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedImageView;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedInstance;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedPhysicalDevice;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedPipeline;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedPipelineCache;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedPipelineLayout;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedQueryPool;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedQueue;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedRenderPass;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedSampler;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedSemaphore;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedShaderModule;
|
||||||
|
|
||||||
|
//=== VK_VERSION_1_1 ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDescriptorUpdateTemplate;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedSamplerYcbcrConversion;
|
||||||
|
|
||||||
|
//=== VK_VERSION_1_3 ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedPrivateDataSlot;
|
||||||
|
|
||||||
|
//=== VK_KHR_surface ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedSurfaceKHR;
|
||||||
|
|
||||||
|
//=== VK_KHR_swapchain ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedSwapchainKHR;
|
||||||
|
|
||||||
|
//=== VK_KHR_display ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDisplayKHR;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDisplayModeKHR;
|
||||||
|
|
||||||
|
//=== VK_EXT_debug_report ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDebugReportCallbackEXT;
|
||||||
|
|
||||||
|
//=== VK_KHR_video_queue ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedVideoSessionKHR;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedVideoSessionParametersKHR;
|
||||||
|
|
||||||
|
//=== VK_NVX_binary_import ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedCuFunctionNVX;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedCuModuleNVX;
|
||||||
|
|
||||||
|
//=== VK_EXT_debug_utils ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDebugUtilsMessengerEXT;
|
||||||
|
|
||||||
|
//=== VK_KHR_acceleration_structure ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedAccelerationStructureKHR;
|
||||||
|
|
||||||
|
//=== VK_EXT_validation_cache ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedValidationCacheEXT;
|
||||||
|
|
||||||
|
//=== VK_NV_ray_tracing ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedAccelerationStructureNV;
|
||||||
|
|
||||||
|
//=== VK_INTEL_performance_query ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedPerformanceConfigurationINTEL;
|
||||||
|
|
||||||
|
//=== VK_KHR_deferred_host_operations ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDeferredOperationKHR;
|
||||||
|
|
||||||
|
//=== VK_NV_device_generated_commands ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutNV;
|
||||||
|
|
||||||
|
# if defined( VK_USE_PLATFORM_FUCHSIA )
|
||||||
|
//=== VK_FUCHSIA_buffer_collection ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedBufferCollectionFUCHSIA;
|
||||||
|
# endif /*VK_USE_PLATFORM_FUCHSIA*/
|
||||||
|
|
||||||
|
//=== VK_EXT_opacity_micromap ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedMicromapEXT;
|
||||||
|
|
||||||
|
//=== VK_NV_optical_flow ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedOpticalFlowSessionNV;
|
||||||
|
|
||||||
|
//=== VK_EXT_shader_object ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedHandleTraits;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedShaderEXT;
|
||||||
|
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
|
||||||
|
|
||||||
//===========================
|
//===========================
|
||||||
//=== COMMAND Definitions ===
|
//=== COMMAND Definitions ===
|
||||||
//===========================
|
//===========================
|
||||||
|
|||||||
1069
vulkan/vulkan_shared.hpp
Normal file
1069
vulkan/vulkan_shared.hpp
Normal file
File diff suppressed because it is too large
Load Diff
@ -44,6 +44,7 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||||||
using VULKAN_HPP_NAMESPACE::ArrayProxy;
|
using VULKAN_HPP_NAMESPACE::ArrayProxy;
|
||||||
using VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries;
|
using VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries;
|
||||||
using VULKAN_HPP_NAMESPACE::Optional;
|
using VULKAN_HPP_NAMESPACE::Optional;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedHandle;
|
||||||
using VULKAN_HPP_NAMESPACE::StridedArrayProxy;
|
using VULKAN_HPP_NAMESPACE::StridedArrayProxy;
|
||||||
using VULKAN_HPP_NAMESPACE::StructureChain;
|
using VULKAN_HPP_NAMESPACE::StructureChain;
|
||||||
using VULKAN_HPP_NAMESPACE::UniqueHandle;
|
using VULKAN_HPP_NAMESPACE::UniqueHandle;
|
||||||
@ -51,9 +52,13 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||||||
|
|
||||||
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
||||||
using VULKAN_HPP_NAMESPACE::ObjectDestroy;
|
using VULKAN_HPP_NAMESPACE::ObjectDestroy;
|
||||||
|
using VULKAN_HPP_NAMESPACE::ObjectDestroyShared;
|
||||||
using VULKAN_HPP_NAMESPACE::ObjectFree;
|
using VULKAN_HPP_NAMESPACE::ObjectFree;
|
||||||
|
using VULKAN_HPP_NAMESPACE::ObjectFreeShared;
|
||||||
using VULKAN_HPP_NAMESPACE::ObjectRelease;
|
using VULKAN_HPP_NAMESPACE::ObjectRelease;
|
||||||
|
using VULKAN_HPP_NAMESPACE::ObjectReleaseShared;
|
||||||
using VULKAN_HPP_NAMESPACE::PoolFree;
|
using VULKAN_HPP_NAMESPACE::PoolFree;
|
||||||
|
using VULKAN_HPP_NAMESPACE::PoolFreeShared;
|
||||||
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
|
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
|
||||||
|
|
||||||
//==================
|
//==================
|
||||||
@ -1344,6 +1349,65 @@ export namespace VULKAN_HPP_NAMESPACE
|
|||||||
using VULKAN_HPP_NAMESPACE::UniqueHandleTraits;
|
using VULKAN_HPP_NAMESPACE::UniqueHandleTraits;
|
||||||
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
|
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
|
||||||
|
|
||||||
|
//======================
|
||||||
|
//=== SHARED HANDLEs ===
|
||||||
|
//======================
|
||||||
|
|
||||||
|
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
||||||
|
|
||||||
|
//=== VK_VERSION_1_0 ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedBuffer;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedBufferView;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedCommandBuffer;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedCommandPool;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDescriptorPool;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDescriptorSet;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDescriptorSetLayout;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDevice;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDeviceMemory;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedEvent;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedFence;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedFramebuffer;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedImage;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedImageView;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedInstance;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedPhysicalDevice;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedPipeline;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedPipelineCache;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedPipelineLayout;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedQueryPool;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedQueue;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedRenderPass;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedSampler;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedSemaphore;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedShaderModule;
|
||||||
|
|
||||||
|
//=== VK_VERSION_1_1 ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedSamplerYcbcrConversion;
|
||||||
|
|
||||||
|
//=== VK_VERSION_1_3 ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedPrivateDataSlot;
|
||||||
|
|
||||||
|
//=== VK_KHR_surface ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedSurfaceKHR;
|
||||||
|
|
||||||
|
//=== VK_KHR_swapchain ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedSwapchainKHR;
|
||||||
|
|
||||||
|
//=== VK_KHR_display ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDisplayKHR;
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDisplayModeKHR;
|
||||||
|
|
||||||
|
//=== VK_EXT_debug_utils ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedDebugUtilsMessengerEXT;
|
||||||
|
|
||||||
|
# if defined( VK_USE_PLATFORM_SCI )
|
||||||
|
//=== VK_NV_external_sci_sync2 ===
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedSemaphoreSciSyncPoolNV;
|
||||||
|
# endif /*VK_USE_PLATFORM_SCI*/
|
||||||
|
using VULKAN_HPP_NAMESPACE::SharedHandleTraits;
|
||||||
|
#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
|
||||||
|
|
||||||
//===========================
|
//===========================
|
||||||
//=== COMMAND Definitions ===
|
//=== COMMAND Definitions ===
|
||||||
//===========================
|
//===========================
|
||||||
|
|||||||
903
vulkan/vulkansc_shared.hpp
Normal file
903
vulkan/vulkansc_shared.hpp
Normal file
@ -0,0 +1,903 @@
|
|||||||
|
// Copyright 2015-2023 The Khronos Group Inc.
|
||||||
|
//
|
||||||
|
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||||
|
//
|
||||||
|
|
||||||
|
// This header is generated from the Khronos Vulkan XML API Registry.
|
||||||
|
|
||||||
|
#ifndef VULKAN_SHARED_HPP
|
||||||
|
#define VULKAN_SHARED_HPP
|
||||||
|
|
||||||
|
#include <atomic> // std::atomic_size_t
|
||||||
|
#include <vulkan/vulkansc.hpp>
|
||||||
|
|
||||||
|
namespace VULKAN_HPP_NAMESPACE
|
||||||
|
{
|
||||||
|
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
class SharedHandleTraits;
|
||||||
|
|
||||||
|
class NoDestructor
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType, typename = void>
|
||||||
|
struct HasDestructorType : std::false_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
struct HasDestructorType<HandleType, decltype( (void)typename SharedHandleTraits<HandleType>::DestructorType() )> : std::true_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType, typename Enable = void>
|
||||||
|
struct GetDestructorType
|
||||||
|
{
|
||||||
|
using type = NoDestructor;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
struct GetDestructorType<HandleType, typename std::enable_if<HasDestructorType<HandleType>::value>::type>
|
||||||
|
{
|
||||||
|
using type = typename SharedHandleTraits<HandleType>::DestructorType;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <class HandleType>
|
||||||
|
using DestructorTypeOf = typename GetDestructorType<HandleType>::type;
|
||||||
|
|
||||||
|
template <class HandleType>
|
||||||
|
struct HasDestructor : std::integral_constant<bool, !std::is_same<DestructorTypeOf<HandleType>, NoDestructor>::value>
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
//=====================================================================================================================
|
||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
class SharedHandle;
|
||||||
|
|
||||||
|
template <typename DestructorType, typename Deleter>
|
||||||
|
struct SharedHeader
|
||||||
|
{
|
||||||
|
SharedHandle<DestructorType> parent;
|
||||||
|
Deleter deleter;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename Deleter>
|
||||||
|
struct SharedHeader<NoDestructor, Deleter>
|
||||||
|
{
|
||||||
|
Deleter deleter;
|
||||||
|
};
|
||||||
|
|
||||||
|
//=====================================================================================================================
|
||||||
|
|
||||||
|
template <typename HeaderType>
|
||||||
|
class ReferenceCounter
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
template <typename... Args>
|
||||||
|
ReferenceCounter( Args &&... control_args ) : m_header( std::forward<Args>( control_args )... ){};
|
||||||
|
ReferenceCounter( const ReferenceCounter & ) = delete;
|
||||||
|
ReferenceCounter & operator=( const ReferenceCounter & ) = delete;
|
||||||
|
|
||||||
|
public:
|
||||||
|
size_t addRef() VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
// Relaxed memory order is sufficient since this does not impose any ordering on other operations
|
||||||
|
return m_ref_cnt.fetch_add( 1, std::memory_order_relaxed );
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t release() VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
// A release memory order to ensure that all releases are ordered
|
||||||
|
return m_ref_cnt.fetch_sub( 1, std::memory_order_release );
|
||||||
|
}
|
||||||
|
|
||||||
|
public:
|
||||||
|
std::atomic_size_t m_ref_cnt{ 1 };
|
||||||
|
HeaderType m_header{};
|
||||||
|
};
|
||||||
|
|
||||||
|
//=====================================================================================================================
|
||||||
|
|
||||||
|
template <typename HandleType, typename HeaderType, typename ForwardType = SharedHandle<HandleType>>
|
||||||
|
class SharedHandleBase
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
SharedHandleBase() = default;
|
||||||
|
|
||||||
|
template <typename... Args>
|
||||||
|
SharedHandleBase( HandleType handle, Args &&... control_args )
|
||||||
|
: m_control( new ReferenceCounter<HeaderType>( std::forward<Args>( control_args )... ) ), m_handle( handle )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
SharedHandleBase( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
o.addRef();
|
||||||
|
m_handle = o.m_handle;
|
||||||
|
m_control = o.m_control;
|
||||||
|
}
|
||||||
|
|
||||||
|
SharedHandleBase( SharedHandleBase && o ) VULKAN_HPP_NOEXCEPT
|
||||||
|
: m_control( o.m_control )
|
||||||
|
, m_handle( o.m_handle )
|
||||||
|
{
|
||||||
|
o.m_handle = nullptr;
|
||||||
|
o.m_control = nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
SharedHandleBase & operator=( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
SharedHandleBase( o ).swap( *this );
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
SharedHandleBase & operator=( SharedHandleBase && o ) VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
SharedHandleBase( std::move( o ) ).swap( *this );
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
~SharedHandleBase()
|
||||||
|
{
|
||||||
|
// only this function owns the last reference to the control block
|
||||||
|
// the same principle is used in the default deleter of std::shared_ptr
|
||||||
|
if ( m_control && ( m_control->release() == 1 ) )
|
||||||
|
{
|
||||||
|
// noop in x86, but does thread synchronization in ARM
|
||||||
|
// it is required to ensure that last thread is getting to destroy the control block
|
||||||
|
// by ordering all atomic operations before this fence
|
||||||
|
std::atomic_thread_fence( std::memory_order_acquire );
|
||||||
|
ForwardType::internalDestroy( getHeader(), m_handle );
|
||||||
|
delete m_control;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public:
|
||||||
|
HandleType get() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return m_handle;
|
||||||
|
}
|
||||||
|
|
||||||
|
HandleType operator*() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return m_handle;
|
||||||
|
}
|
||||||
|
|
||||||
|
explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return bool( m_handle );
|
||||||
|
}
|
||||||
|
|
||||||
|
const HandleType * operator->() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return &m_handle;
|
||||||
|
}
|
||||||
|
|
||||||
|
HandleType * operator->() VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return &m_handle;
|
||||||
|
}
|
||||||
|
|
||||||
|
void reset() VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
SharedHandleBase().swap( *this );
|
||||||
|
}
|
||||||
|
|
||||||
|
void swap( SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
std::swap( m_handle, o.m_handle );
|
||||||
|
std::swap( m_control, o.m_control );
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T = HandleType>
|
||||||
|
typename std::enable_if<HasDestructor<T>::value, const SharedHandle<DestructorTypeOf<HandleType>> &>::type getDestructorType() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return getHeader().parent;
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
template <typename T = HandleType>
|
||||||
|
static typename std::enable_if<!HasDestructor<T>::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
control.deleter.destroy( handle );
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T = HandleType>
|
||||||
|
static typename std::enable_if<HasDestructor<T>::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
control.deleter.destroy( control.parent.get(), handle );
|
||||||
|
}
|
||||||
|
|
||||||
|
const HeaderType & getHeader() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return m_control->m_header;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
void addRef() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
if ( m_control )
|
||||||
|
m_control->addRef();
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
ReferenceCounter<HeaderType> * m_control = nullptr;
|
||||||
|
HandleType m_handle{};
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
class SharedHandle : public SharedHandleBase<HandleType, SharedHeader<DestructorTypeOf<HandleType>, typename SharedHandleTraits<HandleType>::deleter>>
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
using BaseType = SharedHandleBase<HandleType, SharedHeader<DestructorTypeOf<HandleType>, typename SharedHandleTraits<HandleType>::deleter>>;
|
||||||
|
using DeleterType = typename SharedHandleTraits<HandleType>::deleter;
|
||||||
|
friend BaseType;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
template <typename T = HandleType, typename = typename std::enable_if<HasDestructor<T>::value>::type>
|
||||||
|
explicit SharedHandle( HandleType handle, SharedHandle<DestructorTypeOf<HandleType>> parent, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
|
||||||
|
: BaseType( handle, std::move( parent ), std::move( deleter ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T = HandleType, typename = typename std::enable_if<!HasDestructor<T>::value>::type>
|
||||||
|
explicit SharedHandle( HandleType handle, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT : BaseType( handle, std::move( deleter ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
using BaseType::internalDestroy;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
class SharedHandleTraits;
|
||||||
|
|
||||||
|
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 )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
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<DispatchLoaderBase> m_destroy = nullptr;
|
||||||
|
const DispatchLoaderBase * m_dispatch = nullptr;
|
||||||
|
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
class ObjectFreeShared
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
|
||||||
|
|
||||||
|
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<DispatchLoaderBase> m_destroy = nullptr;
|
||||||
|
const DispatchLoaderBase * m_dispatch = nullptr;
|
||||||
|
Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType>
|
||||||
|
class ObjectReleaseShared
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
|
||||||
|
|
||||||
|
template <class Dispatcher>
|
||||||
|
using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const;
|
||||||
|
|
||||||
|
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 )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
public:
|
||||||
|
void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
|
||||||
|
( parent.*m_destroy )( handle, *m_dispatch );
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
DestroyFunctionPointerType<DispatchLoaderBase> m_destroy = nullptr;
|
||||||
|
const DispatchLoaderBase * m_dispatch = nullptr;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType, typename PoolType>
|
||||||
|
class PoolFreeShared
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
|
||||||
|
|
||||||
|
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 );
|
||||||
|
( parent.*m_destroy )( m_pool.get(), 1u, &handle, *m_dispatch );
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
DestroyFunctionPointerType<DispatchLoaderBase> m_destroy = nullptr;
|
||||||
|
const DispatchLoaderBase * m_dispatch = nullptr;
|
||||||
|
SharedHandle<PoolType> m_pool{};
|
||||||
|
};
|
||||||
|
|
||||||
|
//======================
|
||||||
|
//=== SHARED HANDLEs ===
|
||||||
|
//======================
|
||||||
|
|
||||||
|
//=== VK_VERSION_1_0 ===
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<Instance>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = NoDestructor;
|
||||||
|
using deleter = ObjectDestroyShared<Instance>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedInstance = SharedHandle<Instance>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<Device>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = NoDestructor;
|
||||||
|
using deleter = ObjectDestroyShared<Device>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedDevice = SharedHandle<Device>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<Fence>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<Fence>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedFence = SharedHandle<Fence>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<Semaphore>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<Semaphore>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedSemaphore = SharedHandle<Semaphore>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<Event>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<Event>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedEvent = SharedHandle<Event>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<Buffer>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<Buffer>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedBuffer = SharedHandle<Buffer>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<BufferView>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<BufferView>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedBufferView = SharedHandle<BufferView>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<Image>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<Image>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedImage = SharedHandle<Image>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<ImageView>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<ImageView>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedImageView = SharedHandle<ImageView>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<PipelineCache>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<PipelineCache>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedPipelineCache = SharedHandle<PipelineCache>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<Pipeline>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<Pipeline>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedPipeline = SharedHandle<Pipeline>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<PipelineLayout>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<PipelineLayout>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedPipelineLayout = SharedHandle<PipelineLayout>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<Sampler>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<Sampler>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedSampler = SharedHandle<Sampler>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<DescriptorSet>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = PoolFreeShared<DescriptorSet, DescriptorPool>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedDescriptorSet = SharedHandle<DescriptorSet>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<DescriptorSetLayout>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<DescriptorSetLayout>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedDescriptorSetLayout = SharedHandle<DescriptorSetLayout>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<Framebuffer>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<Framebuffer>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedFramebuffer = SharedHandle<Framebuffer>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<RenderPass>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<RenderPass>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedRenderPass = SharedHandle<RenderPass>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<CommandBuffer>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = PoolFreeShared<CommandBuffer, CommandPool>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedCommandBuffer = SharedHandle<CommandBuffer>;
|
||||||
|
|
||||||
|
//=== VK_VERSION_1_1 ===
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<SamplerYcbcrConversion>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<SamplerYcbcrConversion>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedSamplerYcbcrConversion = SharedHandle<SamplerYcbcrConversion>;
|
||||||
|
using SharedSamplerYcbcrConversionKHR = SharedHandle<SamplerYcbcrConversion>;
|
||||||
|
|
||||||
|
//=== VK_VERSION_1_3 ===
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<PrivateDataSlot>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Device;
|
||||||
|
using deleter = ObjectDestroyShared<PrivateDataSlot>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedPrivateDataSlot = SharedHandle<PrivateDataSlot>;
|
||||||
|
using SharedPrivateDataSlotEXT = SharedHandle<PrivateDataSlot>;
|
||||||
|
|
||||||
|
//=== VK_KHR_surface ===
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<SurfaceKHR>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Instance;
|
||||||
|
using deleter = ObjectDestroyShared<SurfaceKHR>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedSurfaceKHR = SharedHandle<SurfaceKHR>;
|
||||||
|
|
||||||
|
//=== VK_EXT_debug_utils ===
|
||||||
|
template <>
|
||||||
|
class SharedHandleTraits<DebugUtilsMessengerEXT>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using DestructorType = Instance;
|
||||||
|
using deleter = ObjectDestroyShared<DebugUtilsMessengerEXT>;
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedDebugUtilsMessengerEXT = SharedHandle<DebugUtilsMessengerEXT>;
|
||||||
|
|
||||||
|
enum class SwapchainOwns
|
||||||
|
{
|
||||||
|
no,
|
||||||
|
yes,
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ImageHeader
|
||||||
|
{
|
||||||
|
SharedHandle<DeleteDestructorOf<VULKAN_HPP_NAMESPACE::Image>> parent{};
|
||||||
|
typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter deleter{};
|
||||||
|
SwapchainOwns swapchainOwned = SwapchainOwns::no;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<VULKAN_HPP_NAMESPACE::Image> : public SharedHandleBase<VULKAN_HPP_NAMESPACE::Image, ImageHeader>
|
||||||
|
{
|
||||||
|
using BaseType = SharedHandleBase<VULKAN_HPP_NAMESPACE::Image, ImageHeader>;
|
||||||
|
using DeleterType = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter;
|
||||||
|
friend BaseType;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( VULKAN_HPP_NAMESPACE::Image handle,
|
||||||
|
SharedHandle<DeleteDestructorOf<VULKAN_HPP_NAMESPACE::Image>> parent,
|
||||||
|
SwapchainOwns swapchain_owned = SwapchainOwns::no,
|
||||||
|
DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
|
||||||
|
: BaseType( handle, std::move( parent ), std::move( deleter ), swapchain_owned )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
static void internalDestroy( const ImageHeader & control, VULKAN_HPP_NAMESPACE::Image handle ) VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
if ( control.swapchainOwned == SwapchainOwns::no )
|
||||||
|
{
|
||||||
|
control.deleter.destroy( control.parent.get(), handle );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct SwapchainHeader
|
||||||
|
{
|
||||||
|
SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> surface{};
|
||||||
|
SharedHandle<DeleteDestructorOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>> parent{};
|
||||||
|
typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter deleter{};
|
||||||
|
};
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR> : public SharedHandleBase<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainHeader>
|
||||||
|
{
|
||||||
|
using BaseType = SharedHandleBase<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainHeader>;
|
||||||
|
using DeleterType = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter;
|
||||||
|
friend BaseType;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( VULKAN_HPP_NAMESPACE::SwapchainKHR handle,
|
||||||
|
SharedHandle<DeleteDestructorOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>> parent,
|
||||||
|
SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> surface,
|
||||||
|
DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
|
||||||
|
: BaseType( handle, std::move( surface ), std::move( parent ), std::move( deleter ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
public:
|
||||||
|
const SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> & getSurface() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return getHeader().surface;
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
using BaseType::internalDestroy;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename HandleType, typename DestructorType>
|
||||||
|
class SharedHandleBaseNoDestroy : public SharedHandleBase<HandleType, DestructorType>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
using SharedHandleBase<HandleType, DestructorType>::SharedHandleBase;
|
||||||
|
|
||||||
|
const DestructorType & getDestructorType() const VULKAN_HPP_NOEXCEPT
|
||||||
|
{
|
||||||
|
return SharedHandleBase<HandleType, DestructorType>::getHeader();
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
static void internalDestroy( const DestructorType &, HandleType ) VULKAN_HPP_NOEXCEPT {}
|
||||||
|
};
|
||||||
|
|
||||||
|
//=== VK_VERSION_1_0 ===
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<PhysicalDevice> : public SharedHandleBaseNoDestroy<PhysicalDevice, SharedInstance>
|
||||||
|
{
|
||||||
|
friend SharedHandleBase<PhysicalDevice, SharedInstance>;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( PhysicalDevice handle, SharedInstance parent ) noexcept
|
||||||
|
: SharedHandleBaseNoDestroy<PhysicalDevice, SharedInstance>( handle, std::move( parent ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedPhysicalDevice = SharedHandle<PhysicalDevice>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<Queue> : public SharedHandleBaseNoDestroy<Queue, SharedDevice>
|
||||||
|
{
|
||||||
|
friend SharedHandleBase<Queue, SharedDevice>;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( Queue handle, SharedDevice parent ) noexcept : SharedHandleBaseNoDestroy<Queue, SharedDevice>( handle, std::move( parent ) ) {}
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedQueue = SharedHandle<Queue>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<DeviceMemory> : public SharedHandleBaseNoDestroy<DeviceMemory, SharedDevice>
|
||||||
|
{
|
||||||
|
friend SharedHandleBase<DeviceMemory, SharedDevice>;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( DeviceMemory handle, SharedDevice parent ) noexcept
|
||||||
|
: SharedHandleBaseNoDestroy<DeviceMemory, SharedDevice>( handle, std::move( parent ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedDeviceMemory = SharedHandle<DeviceMemory>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<QueryPool> : public SharedHandleBaseNoDestroy<QueryPool, SharedDevice>
|
||||||
|
{
|
||||||
|
friend SharedHandleBase<QueryPool, SharedDevice>;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( QueryPool handle, SharedDevice parent ) noexcept : SharedHandleBaseNoDestroy<QueryPool, SharedDevice>( handle, std::move( parent ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedQueryPool = SharedHandle<QueryPool>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<ShaderModule> : public SharedHandleBaseNoDestroy<ShaderModule, SharedDevice>
|
||||||
|
{
|
||||||
|
friend SharedHandleBase<ShaderModule, SharedDevice>;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( ShaderModule handle, SharedDevice parent ) noexcept
|
||||||
|
: SharedHandleBaseNoDestroy<ShaderModule, SharedDevice>( handle, std::move( parent ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedShaderModule = SharedHandle<ShaderModule>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<DescriptorPool> : public SharedHandleBaseNoDestroy<DescriptorPool, SharedDevice>
|
||||||
|
{
|
||||||
|
friend SharedHandleBase<DescriptorPool, SharedDevice>;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( DescriptorPool handle, SharedDevice parent ) noexcept
|
||||||
|
: SharedHandleBaseNoDestroy<DescriptorPool, SharedDevice>( handle, std::move( parent ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedDescriptorPool = SharedHandle<DescriptorPool>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<CommandPool> : public SharedHandleBaseNoDestroy<CommandPool, SharedDevice>
|
||||||
|
{
|
||||||
|
friend SharedHandleBase<CommandPool, SharedDevice>;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( CommandPool handle, SharedDevice parent ) noexcept
|
||||||
|
: SharedHandleBaseNoDestroy<CommandPool, SharedDevice>( handle, std::move( parent ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedCommandPool = SharedHandle<CommandPool>;
|
||||||
|
|
||||||
|
//=== VK_KHR_swapchain ===
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<SwapchainKHR> : public SharedHandleBaseNoDestroy<SwapchainKHR, SharedDevice>
|
||||||
|
{
|
||||||
|
friend SharedHandleBase<SwapchainKHR, SharedDevice>;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( SwapchainKHR handle, SharedDevice parent ) noexcept
|
||||||
|
: SharedHandleBaseNoDestroy<SwapchainKHR, SharedDevice>( handle, std::move( parent ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedSwapchainKHR = SharedHandle<SwapchainKHR>;
|
||||||
|
|
||||||
|
//=== VK_KHR_display ===
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<DisplayKHR> : public SharedHandleBaseNoDestroy<DisplayKHR, SharedPhysicalDevice>
|
||||||
|
{
|
||||||
|
friend SharedHandleBase<DisplayKHR, SharedPhysicalDevice>;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( DisplayKHR handle, SharedPhysicalDevice parent ) noexcept
|
||||||
|
: SharedHandleBaseNoDestroy<DisplayKHR, SharedPhysicalDevice>( handle, std::move( parent ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedDisplayKHR = SharedHandle<DisplayKHR>;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<DisplayModeKHR> : public SharedHandleBaseNoDestroy<DisplayModeKHR, SharedDisplayKHR>
|
||||||
|
{
|
||||||
|
friend SharedHandleBase<DisplayModeKHR, SharedDisplayKHR>;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( DisplayModeKHR handle, SharedDisplayKHR parent ) noexcept
|
||||||
|
: SharedHandleBaseNoDestroy<DisplayModeKHR, SharedDisplayKHR>( handle, std::move( parent ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedDisplayModeKHR = SharedHandle<DisplayModeKHR>;
|
||||||
|
|
||||||
|
# if defined( VK_USE_PLATFORM_SCI )
|
||||||
|
//=== VK_NV_external_sci_sync2 ===
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class SharedHandle<SemaphoreSciSyncPoolNV> : public SharedHandleBaseNoDestroy<SemaphoreSciSyncPoolNV, SharedDevice>
|
||||||
|
{
|
||||||
|
friend SharedHandleBase<SemaphoreSciSyncPoolNV, SharedDevice>;
|
||||||
|
|
||||||
|
public:
|
||||||
|
SharedHandle() = default;
|
||||||
|
|
||||||
|
explicit SharedHandle( SemaphoreSciSyncPoolNV handle, SharedDevice parent ) noexcept
|
||||||
|
: SharedHandleBaseNoDestroy<SemaphoreSciSyncPoolNV, SharedDevice>( handle, std::move( parent ) )
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
using SharedSemaphoreSciSyncPoolNV = SharedHandle<SemaphoreSciSyncPoolNV>;
|
||||||
|
# endif /*VK_USE_PLATFORM_SCI*/
|
||||||
|
#endif // !VULKAN_HPP_NO_SMART_HANDLE
|
||||||
|
} // namespace VULKAN_HPP_NAMESPACE
|
||||||
|
#endif // VULKAN_SHARED_HPP
|
||||||
Loading…
Reference in New Issue
Block a user