From ab08f20c01f4b65749b56b12b8ac231952cdcd44 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20S=C3=BC=C3=9Fenbach?= Date: Wed, 8 Feb 2023 17:21:03 +0100 Subject: [PATCH] Sort handle classes by feature and extension. (#1500) --- VulkanHppGenerator.cpp | 166 ++++--- VulkanHppGenerator.hpp | 7 +- vulkan/vulkan_handles.hpp | 890 +++++++++++++++++++++----------------- 3 files changed, 609 insertions(+), 454 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index f152ea7..a0124e9 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -193,14 +193,19 @@ void VulkanHppGenerator::generateVulkanHandlesHppFile() const namespace VULKAN_HPP_NAMESPACE { ${structForwardDeclarations} +${handleForwardDeclarations} +${uniqueHandles} ${handles} } // namespace VULKAN_HPP_NAMESPACE #endif )"; - std::string str = replaceWithMap( - vulkanHandlesHppTemplate, - { { "handles", generateHandles() }, { "licenseHeader", m_vulkanLicenseHeader }, { "structForwardDeclarations", generateStructForwardDeclarations() } } ); + std::string str = replaceWithMap( vulkanHandlesHppTemplate, + { { "handles", generateHandles() }, + { "handleForwardDeclarations", generateHandleForwardDeclarations() }, + { "licenseHeader", m_vulkanLicenseHeader }, + { "structForwardDeclarations", generateStructForwardDeclarations() }, + { "uniqueHandles", generateUniqueHandles() } } ); writeToFile( str, vulkan_handles_hpp ); } @@ -545,7 +550,7 @@ void VulkanHppGenerator::addCommand( std::string const & name, CommandData & com { // find the handle this command is going to be associated to checkForError( !commandData.params.empty(), commandData.xmlLine, "command <" + name + "> with no params" ); - std::map::iterator handleIt = m_handles.find( commandData.params[0].type.type ); + auto handleIt = m_handles.find( commandData.params[0].type.type ); if ( handleIt == m_handles.end() ) { handleIt = m_handles.begin(); @@ -5626,17 +5631,6 @@ std::string VulkanHppGenerator::generateHandle( std::pairfirst == "vkCreateInstance" ) - { - // special handling for createInstance, as we need to explicitly place the forward declarations and the - // deleter classes here -#if !defined( NDEBUG ) - auto handleIt = m_handles.find( "" ); - assert( ( handleIt != m_handles.end() ) && ( handleIt->second.childrenHandles.size() == 2 ) ); - assert( handleIt->second.childrenHandles.find( "VkInstance" ) != handleIt->second.childrenHandles.end() ); -#endif - - str += generateUniqueTypes( "", { "VkInstance" } ); - } - str += "\n"; - - str += generateCommand( commandIt->first, commandIt->second, 0, false, false ); + str += "\n" + generateCommand( commandIt->first, commandIt->second, 0, false, false ); } } } @@ -5894,6 +5874,46 @@ std::string VulkanHppGenerator::generateHandleEmpty( HandleData const & handleDa return str; } +std::string VulkanHppGenerator::generateHandleForwardDeclarations() const +{ + const std::string fowardDeclarationsTemplate = R"( + //=================================== + //=== HANDLE forward declarations === + //=================================== + +${forwardDeclarations} +)"; + + std::string forwardDeclarations; + for ( auto const & feature : m_features ) + { + forwardDeclarations += generateHandleForwardDeclarations( feature.second.requireData, feature.first ); + } + for ( auto const & extIt : m_extensionsByNumber ) + { + forwardDeclarations += generateHandleForwardDeclarations( extIt.second->second.requireData, extIt.second->first ); + } + + return replaceWithMap( fowardDeclarationsTemplate, { { "forwardDeclarations", forwardDeclarations } } ); +} + +std::string VulkanHppGenerator::generateHandleForwardDeclarations( std::vector 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 += "class " + stripPrefix( handleIt->first, "Vk" ) + ";\n"; + } + } + } + return addTitleAndProtection( title, str ); +} + std::string VulkanHppGenerator::generateHandleHashStructures( std::vector const & requireData, std::string const & title ) const { const std::string hashTemplate = R"( @@ -9806,56 +9826,81 @@ ${leave})"; { { "constructors", constructors }, { "enter", enter }, { "leave", leave }, { "members", members }, { "setters", setters }, { "unionName", unionName } } ); } -std::string VulkanHppGenerator::generateUniqueTypes( std::string const & parentType, std::set const & childrenTypes ) const +std::string VulkanHppGenerator::generateUniqueHandle( std::pair const & handleData ) const { - std::string childrenTraits; - for ( auto const & childType : childrenTypes ) + if ( !handleData.second.deleteCommand.empty() ) { - auto handleIt = m_handles.find( childType ); - assert( handleIt != m_handles.end() ); - - std::string type = stripPrefix( childType, "Vk" ); - - auto [enter, leave] = generateProtection( handleIt->second.alias.empty() ? getProtectFromType( handleIt->first ) : "" ); - + std::string type = stripPrefix( handleData.first, "Vk" ); std::string aliasHandle; - if ( !handleIt->second.alias.empty() ) + if ( !handleData.second.alias.empty() ) { static const std::string aliasHandleTemplate = - R"( using Unique${aliasType} = UniqueHandle<${type}, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>; -)"; + R"( using Unique${aliasType} = UniqueHandle<${type}, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;)"; - aliasHandle += replaceWithMap( aliasHandleTemplate, { { "aliasType", stripPrefix( handleIt->second.alias, "Vk" ) }, { "type", type } } ); + aliasHandle += replaceWithMap( aliasHandleTemplate, { { "aliasType", stripPrefix( handleData.second.alias, "Vk" ) }, { "type", type } } ); } - static const std::string traitsTemplate = R"(${enter} template + static const std::string uniqueHandleTemplate = R"( template class UniqueHandleTraits<${type}, Dispatch> { public: using deleter = ${deleterType}${deleterAction}<${deleterParent}${deleterPool}, Dispatch>; }; using Unique${type} = UniqueHandle<${type}, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>; -${aliasHandle}${leave})"; +${aliasHandle})"; - childrenTraits += replaceWithMap( traitsTemplate, - { { "aliasHandle", aliasHandle }, - { "deleterAction", ( handleIt->second.deleteCommand.substr( 2, 4 ) == "Free" ) ? "Free" : "Destroy" }, - { "deleterParent", parentType.empty() ? "NoParent" : stripPrefix( parentType, "Vk" ) }, - { "deleterPool", handleIt->second.deletePool.empty() ? "" : ", " + stripPrefix( handleIt->second.deletePool, "Vk" ) }, - { "deleterType", handleIt->second.deletePool.empty() ? "Object" : "Pool" }, - { "enter", enter }, - { "leave", leave }, - { "type", type } } ); + return replaceWithMap( uniqueHandleTemplate, + { { "aliasHandle", aliasHandle }, + { "deleterAction", ( handleData.second.deleteCommand.substr( 2, 4 ) == "Free" ) ? "Free" : "Destroy" }, + { "deleterParent", handleData.second.deleteParent.empty() ? "NoParent" : stripPrefix(handleData.second.deleteParent, "Vk" ) }, + { "deleterPool", handleData.second.deletePool.empty() ? "" : ", " + stripPrefix( handleData.second.deletePool, "Vk" ) }, + { "deleterType", handleData.second.deletePool.empty() ? "Object" : "Pool" }, + { "type", type } } ); } + return ""; +} - static const std::string uniqueTypeTemplate = R"( +std::string VulkanHppGenerator::generateUniqueHandle( std::vector 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 += generateUniqueHandle( *handleIt ); + } + } + } + return addTitleAndProtection( title, str ); +} + +std::string VulkanHppGenerator::generateUniqueHandles() const +{ + std::string uniqueHandlesTemplate = R"( #ifndef VULKAN_HPP_NO_SMART_HANDLE -${parentClass}${childrenTraits}#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ + //====================== + //=== UNIQUE HANDLEs === + //====================== + +${uniqueHandles} +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ )"; - return replaceWithMap( - uniqueTypeTemplate, - { { "childrenTraits", childrenTraits }, { "parentClass", parentType.empty() ? "" : ( " class " + stripPrefix( parentType, "Vk" ) + ";\n" ) } } ); + std::string uniqueHandles; + for ( auto const & feature : m_features ) + { + uniqueHandles += generateUniqueHandle( feature.second.requireData, feature.first ); + } + for ( auto const & extIt : m_extensionsByNumber ) + { + uniqueHandles += generateUniqueHandle( extIt.second->second.requireData, extIt.second->first ); + } + assert( uniqueHandles.back() == '\n'); + uniqueHandles.pop_back(); + return replaceWithMap( uniqueHandlesTemplate, { { "uniqueHandles", uniqueHandles } } ); } std::string VulkanHppGenerator::generateVectorSizeCheck( std::string const & name, @@ -12837,6 +12882,7 @@ void VulkanHppGenerator::registerDeleter( std::string const & name, std::pairsecond.deleteCommand = name; + handleIt->second.deleteParent = key; } } diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index b4b330a..8d86e4c 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -339,6 +339,7 @@ private: std::set childrenHandles; std::set commands; std::string deleteCommand; + std::string deleteParent; std::string deletePool; std::string objTypeEnum; std::string parent; @@ -717,6 +718,8 @@ private: std::string generateHandleCommandDeclarations( std::set const & commands ) const; std::string generateHandleDependencies( std::pair const & handle, std::set & listedHandles ) const; std::string generateHandleEmpty( HandleData const & handleData ) const; + std::string generateHandleForwardDeclarations() const; + std::string generateHandleForwardDeclarations( std::vector const & requireData, std::string const & title ) const; std::string generateHandleHashStructures( std::vector const & requireData, std::string const & title ) const; std::string generateHandleHashStructures() const; std::string generateHandles() const; @@ -889,7 +892,9 @@ private: std::vector const & dataTypes, CommandFlavourFlags flavourFlags ) const; std::string generateUnion( std::pair const & structure ) const; - std::string generateUniqueTypes( std::string const & parentType, std::set const & childrenTypes ) const; + std::string generateUniqueHandle( std::pair const & handleData ) const; + std::string generateUniqueHandle( std::vector const & requireData, std::string const & title ) const; + std::string generateUniqueHandles() const; std::string generateVectorSizeCheck( std::string const & name, CommandData const & commandData, size_t initialSkipCount, diff --git a/vulkan/vulkan_handles.hpp b/vulkan/vulkan_handles.hpp index eeb6be2..ceba1d5 100644 --- a/vulkan/vulkan_handles.hpp +++ b/vulkan/vulkan_handles.hpp @@ -1565,6 +1565,503 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_pipeline_library_group_handles === struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; + //=================================== + //=== HANDLE forward declarations === + //=================================== + + //=== VK_VERSION_1_0 === + class Instance; + class PhysicalDevice; + class Device; + class Queue; + class DeviceMemory; + class Fence; + class Semaphore; + class Event; + class QueryPool; + class Buffer; + class BufferView; + class Image; + class ImageView; + class ShaderModule; + class PipelineCache; + class Pipeline; + class PipelineLayout; + class Sampler; + class DescriptorPool; + class DescriptorSet; + class DescriptorSetLayout; + class Framebuffer; + class RenderPass; + class CommandPool; + class CommandBuffer; + + //=== VK_VERSION_1_1 === + class SamplerYcbcrConversion; + class DescriptorUpdateTemplate; + + //=== VK_VERSION_1_3 === + class PrivateDataSlot; + + //=== VK_KHR_surface === + class SurfaceKHR; + + //=== VK_KHR_swapchain === + class SwapchainKHR; + + //=== VK_KHR_display === + class DisplayKHR; + class DisplayModeKHR; + + //=== VK_EXT_debug_report === + class DebugReportCallbackEXT; + + //=== VK_KHR_video_queue === + class VideoSessionKHR; + class VideoSessionParametersKHR; + + //=== VK_NVX_binary_import === + class CuModuleNVX; + class CuFunctionNVX; + + //=== VK_EXT_debug_utils === + class DebugUtilsMessengerEXT; + + //=== VK_KHR_acceleration_structure === + class AccelerationStructureKHR; + + //=== VK_EXT_validation_cache === + class ValidationCacheEXT; + + //=== VK_NV_ray_tracing === + class AccelerationStructureNV; + + //=== VK_INTEL_performance_query === + class PerformanceConfigurationINTEL; + + //=== VK_KHR_deferred_host_operations === + class DeferredOperationKHR; + + //=== VK_NV_device_generated_commands === + class IndirectCommandsLayoutNV; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + class BufferCollectionFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_opacity_micromap === + class MicromapEXT; + + //=== VK_NV_optical_flow === + class OpticalFlowSessionNV; + +#ifndef VULKAN_HPP_NO_SMART_HANDLE + //====================== + //=== UNIQUE HANDLEs === + //====================== + + //=== VK_VERSION_1_0 === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueInstance = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueDevice = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectFree; + }; + + using UniqueDeviceMemory = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueFence = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueSemaphore = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueEvent = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueQueryPool = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueBuffer = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueBufferView = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueImage = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueImageView = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueShaderModule = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniquePipelineCache = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniquePipeline = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniquePipelineLayout = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueSampler = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueDescriptorPool = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = PoolFree; + }; + + using UniqueDescriptorSet = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueDescriptorSetLayout = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueFramebuffer = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueRenderPass = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueCommandPool = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = PoolFree; + }; + + using UniqueCommandBuffer = UniqueHandle; + + //=== VK_VERSION_1_1 === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueSamplerYcbcrConversion = UniqueHandle; + using UniqueSamplerYcbcrConversionKHR = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueDescriptorUpdateTemplate = UniqueHandle; + using UniqueDescriptorUpdateTemplateKHR = UniqueHandle; + + //=== VK_VERSION_1_3 === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniquePrivateDataSlot = UniqueHandle; + using UniquePrivateDataSlotEXT = UniqueHandle; + + //=== VK_KHR_surface === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueSurfaceKHR = UniqueHandle; + + //=== VK_KHR_swapchain === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueSwapchainKHR = UniqueHandle; + + //=== VK_EXT_debug_report === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueDebugReportCallbackEXT = UniqueHandle; + + //=== VK_KHR_video_queue === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueVideoSessionKHR = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueVideoSessionParametersKHR = UniqueHandle; + + //=== VK_NVX_binary_import === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueCuModuleNVX = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueCuFunctionNVX = UniqueHandle; + + //=== VK_EXT_debug_utils === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueDebugUtilsMessengerEXT = UniqueHandle; + + //=== VK_KHR_acceleration_structure === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueAccelerationStructureKHR = UniqueHandle; + + //=== VK_EXT_validation_cache === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueValidationCacheEXT = UniqueHandle; + + //=== VK_NV_ray_tracing === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueAccelerationStructureNV = UniqueHandle; + + //=== VK_KHR_deferred_host_operations === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueDeferredOperationKHR = UniqueHandle; + + //=== VK_NV_device_generated_commands === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueIndirectCommandsLayoutNV = UniqueHandle; + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueBufferCollectionFUCHSIA = UniqueHandle; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_opacity_micromap === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueMicromapEXT = UniqueHandle; + + //=== VK_NV_optical_flow === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + + using UniqueOpticalFlowSessionNV = UniqueHandle; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ + //=============== //=== HANDLEs === //=============== @@ -7561,346 +8058,6 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - class Device; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueAccelerationStructureKHR = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueAccelerationStructureNV = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueBuffer = UniqueHandle; -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueBufferCollectionFUCHSIA = UniqueHandle; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueBufferView = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = PoolFree; - }; - - using UniqueCommandBuffer = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueCommandPool = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueCuFunctionNVX = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueCuModuleNVX = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueDeferredOperationKHR = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueDescriptorPool = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = PoolFree; - }; - - using UniqueDescriptorSet = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueDescriptorSetLayout = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueDescriptorUpdateTemplate = UniqueHandle; - using UniqueDescriptorUpdateTemplateKHR = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectFree; - }; - - using UniqueDeviceMemory = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueEvent = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueFence = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueFramebuffer = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueImage = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueImageView = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueIndirectCommandsLayoutNV = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueMicromapEXT = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueOpticalFlowSessionNV = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniquePipeline = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniquePipelineCache = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniquePipelineLayout = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniquePrivateDataSlot = UniqueHandle; - using UniquePrivateDataSlotEXT = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueQueryPool = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueRenderPass = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueSampler = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueSamplerYcbcrConversion = UniqueHandle; - using UniqueSamplerYcbcrConversionKHR = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueSemaphore = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueShaderModule = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueSwapchainKHR = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueValidationCacheEXT = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueVideoSessionKHR = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueVideoSessionParametersKHR = UniqueHandle; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - class Device { public: @@ -12574,17 +12731,6 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueDevice = UniqueHandle; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - class PhysicalDevice { public: @@ -13941,37 +14087,6 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; -#ifndef VULKAN_HPP_NO_SMART_HANDLE - class Instance; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueDebugReportCallbackEXT = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueDebugUtilsMessengerEXT = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueSurfaceKHR = UniqueHandle; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - class Instance { public: @@ -14639,17 +14754,6 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_VERSION_1_0 === -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template - class UniqueHandleTraits - { - public: - using deleter = ObjectDestroy; - }; - - using UniqueInstance = UniqueHandle; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - template VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,