From fa613080a74572b1b3c2f61b388b4b18c7ba2618 Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Mon, 24 Aug 2020 10:06:20 +0200 Subject: [PATCH] Introduce mapping between DebugReportObjectType enum value and the corresponding cpp handle type. + new type trait isVulkanHandleType<> --- VulkanHppGenerator.cpp | 198 +++++--- vulkan/vulkan.hpp | 1010 ++++++++++++++++++++++++++++++++-------- 2 files changed, 954 insertions(+), 254 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index 2e0be4c..7ef4802 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -261,7 +261,10 @@ void checkAttributes( int line, } } -void checkedAssignment( std::string & str, std::string const& leave, std::string const& commandName, std::string aliasName ) +void checkedAssignment( std::string & str, + std::string const & leave, + std::string const & commandName, + std::string aliasName ) { str.erase( str.length() - leave.length() ); str += " if ( !" + commandName + " ) " + commandName + " = " + aliasName + ";\n" + leave; @@ -3297,7 +3300,8 @@ ${enter} class ${className} public: using CType = Vk${className}; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::e${className}; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::e${className}; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::${debugReportObjectType}; public: VULKAN_HPP_CONSTEXPR ${className}() VULKAN_HPP_NOEXCEPT @@ -3363,26 +3367,57 @@ ${commands} private: Vk${className} m_${memberName}; }; - static_assert( sizeof( ${className} ) == sizeof( Vk${className} ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::${className} ) == sizeof( Vk${className} ), "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED("vk::cpp_type is deprecated. Use vk::CppType instead.") cpp_type { - using type = ${className}; + using type = VULKAN_HPP_NAMESPACE::${className}; }; template <> - struct CppType + struct CppType { - using Type = ${className}; + using Type = VULKAN_HPP_NAMESPACE::${className}; + }; + +${CppTypeFromDebugReportObjectTypeEXT} + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; )"; + std::string className = stripPrefix( handleData.first, "Vk" ); + + auto enumIt = m_enums.find( "VkDebugReportObjectTypeEXT" ); + assert( enumIt != m_enums.end() ); + auto valueIt = std::find_if( enumIt->second.values.begin(), + enumIt->second.values.end(), + [&className]( EnumValueData const & evd ) { return evd.vkValue == "e" + className; } ); + static const std::string cppTypeFromDebugReportObjectTypeEXTTemplate = R"( + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::${className}; + }; +)"; + std::string cppTypeFromDebugReportObjectTypeEXT = + ( valueIt != enumIt->second.values.end() ) + ? replaceWithMap( cppTypeFromDebugReportObjectTypeEXTTemplate, { { "className", className } } ) + : ""; + std::string debugReportObjectType = ( valueIt != enumIt->second.values.end() ) ? valueIt->vkValue : "eUnknown"; + std::string enter, leave; std::tie( enter, leave ) = generateProtection( handleData.first, !handleData.second.alias.empty() ); + str += replaceWithMap( templateString, - { { "className", stripPrefix( handleData.first, "Vk" ) }, + { { "className", className }, { "commands", commands }, + { "CppTypeFromDebugReportObjectTypeEXT", cppTypeFromDebugReportObjectTypeEXT }, + { "debugReportObjectType", debugReportObjectType }, { "enter", enter }, { "memberName", startLowerCase( stripPrefix( handleData.first, "Vk" ) ) } } ); @@ -4579,12 +4614,16 @@ void VulkanHppGenerator::EnumData::addEnumValue( int line, void VulkanHppGenerator::checkCorrectness() { check( !m_vulkanLicenseHeader.empty(), -1, "missing license header" ); + + // baseType checks for ( auto const & baseType : m_baseTypes ) { check( m_types.find( baseType.second.type ) != m_types.end(), baseType.second.xmlLine, "basetype type <" + baseType.second.type + "> not specified" ); } + + // bitmask checks for ( auto const & bitmask : m_bitmasks ) { if ( !bitmask.second.requirements.empty() ) @@ -4594,6 +4633,52 @@ void VulkanHppGenerator::checkCorrectness() "bitmask requires unknown <" + bitmask.second.requirements + ">" ); } } + + // prepare command checks + auto resultIt = m_enums.find( "VkResult" ); + assert( resultIt != m_enums.end() ); + std::set resultCodes; + for ( auto rc : resultIt->second.values ) + { + resultCodes.insert( rc.vulkanValue ); + } + for ( auto rc : resultIt->second.aliases ) + { + resultCodes.insert( rc.first ); + } + + // command checks + for ( auto const & command : m_commands ) + { + for ( auto const & ec : command.second.errorCodes ) + { + check( resultCodes.find( ec ) != resultCodes.end(), + command.second.xmlLine, + "command uses unknown error code <" + ec + ">" ); + } + for ( auto const & sc : command.second.successCodes ) + { + check( resultCodes.find( sc ) != resultCodes.end(), + command.second.xmlLine, + "command uses unknown success code <" + sc + ">" ); + } + // check that functions returning a VkResult specify successcodes + check( ( command.second.returnType != "VkResult" ) || !command.second.successCodes.empty(), + command.second.xmlLine, + "missing successcodes on command <" + command.first + "> returning VkResult!" ); + + for ( auto const & p : command.second.params ) + { + check( m_types.find( p.type.type ) != m_types.end(), + p.xmlLine, + "comand uses parameter of unknown type <" + p.type.type + ">" ); + } + check( m_types.find( command.second.returnType ) != m_types.end(), + command.second.xmlLine, + "command uses unknown return type <" + command.second.returnType + ">" ); + } + + // extension checks for ( auto const & extension : m_extensions ) { if ( !extension.second.deprecatedBy.empty() ) @@ -4624,6 +4709,8 @@ void VulkanHppGenerator::checkCorrectness() "unknown extension requires <" + require.first + ">" ); } } + + // funcPointer checks for ( auto const & funcPointer : m_funcPointers ) { if ( !funcPointer.second.requirements.empty() ) @@ -4634,6 +4721,43 @@ void VulkanHppGenerator::checkCorrectness() } } + // handle checks + auto debugReportObjectTypeIt = m_enums.find( "VkDebugReportObjectTypeEXT" ); + assert( debugReportObjectTypeIt != m_enums.end() ); + for ( auto const & handle : m_handles ) + { + for ( auto const & parent : handle.second.parents ) + { + check( m_handles.find( parent ) != m_handles.end(), + handle.second.xmlLine, + "handle with unknown parent <" + parent + ">" ); + } + + if ( !handle.first.empty() ) + { + std::string debugReportObjectType = "e" + stripPrefix( handle.first, "Vk" ); + auto valueIt = std::find_if( + debugReportObjectTypeIt->second.values.begin(), + debugReportObjectTypeIt->second.values.end(), + [&debugReportObjectType]( EnumValueData const & evd ) { return evd.vkValue == debugReportObjectType; } ); + warn( valueIt != debugReportObjectTypeIt->second.values.end(), + handle.second.xmlLine, + "Handle <" + handle.first + "> specified without a corresponding VkDebugReportObjectTypeEXT enum value" ); + } + } + for ( auto const & debugReportObjectTyeValue : debugReportObjectTypeIt->second.values ) + { + if ( debugReportObjectTyeValue.vkValue != "eUnknown" ) + { + std::string handleName = "Vk" + stripPrefix( debugReportObjectTyeValue.vkValue, "e" ); + check( m_handles.find( handleName ) != m_handles.end(), + debugReportObjectTyeValue.xmlLine, + "DebugReportObjectTypeEXT value <" + debugReportObjectTyeValue.vulkanValue + + "> without corresponding handle" ); + } + } + + // structure checks std::set sTypeValues; for ( auto const & structure : m_structures ) { @@ -4724,6 +4848,8 @@ void VulkanHppGenerator::checkCorrectness() } } + // enum checks + // enum VkStructureType checks (need to be after structure checks) auto structureTypeIt = m_enums.find( "VkStructureType" ); assert( structureTypeIt != m_enums.end() ); for ( auto const & enumValue : structureTypeIt->second.values ) @@ -4743,58 +4869,6 @@ void VulkanHppGenerator::checkCorrectness() } } assert( sTypeValues.empty() ); - - auto resultIt = m_enums.find( "VkResult" ); - assert( resultIt != m_enums.end() ); - std::set resultCodes; - for ( auto rc : resultIt->second.values ) - { - resultCodes.insert( rc.vulkanValue ); - } - for ( auto rc : resultIt->second.aliases ) - { - resultCodes.insert( rc.first ); - } - - for ( auto const & command : m_commands ) - { - for ( auto const & ec : command.second.errorCodes ) - { - check( resultCodes.find( ec ) != resultCodes.end(), - command.second.xmlLine, - "command uses unknown error code <" + ec + ">" ); - } - for ( auto const & sc : command.second.successCodes ) - { - check( resultCodes.find( sc ) != resultCodes.end(), - command.second.xmlLine, - "command uses unknown success code <" + sc + ">" ); - } - // check that functions returning a VkResult specify successcodes - check( ( command.second.returnType != "VkResult" ) || !command.second.successCodes.empty(), - command.second.xmlLine, - "missing successcodes on command <" + command.first + "> returning VkResult!" ); - - for ( auto const & p : command.second.params ) - { - check( m_types.find( p.type.type ) != m_types.end(), - p.xmlLine, - "comand uses parameter of unknown type <" + p.type.type + ">" ); - } - check( m_types.find( command.second.returnType ) != m_types.end(), - command.second.xmlLine, - "command uses unknown return type <" + command.second.returnType + ">" ); - } - - for ( auto const & handle : m_handles ) - { - for ( auto const & parent : handle.second.parents ) - { - check( m_handles.find( parent ) != m_handles.end(), - handle.second.xmlLine, - "handle with unknown parent <" + parent + ">" ); - } - } } bool VulkanHppGenerator::containsArray( std::string const & type ) const @@ -9012,6 +9086,12 @@ namespace std template struct CppType {}; + + template + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false; + }; )"; try diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 4f34776..a0b7095 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -4998,6 +4998,12 @@ namespace VULKAN_HPP_NAMESPACE struct CppType {}; + template + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false; + }; + #ifdef VK_ENABLE_BETA_EXTENSIONS enum class AccelerationStructureBuildTypeKHR { @@ -16675,7 +16681,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkAccelerationStructureKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR; public: VULKAN_HPP_CONSTEXPR AccelerationStructureKHR() VULKAN_HPP_NOEXCEPT : m_accelerationStructureKHR( VK_NULL_HANDLE ) @@ -16741,20 +16750,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkAccelerationStructureKHR m_accelerationStructureKHR; }; - static_assert( sizeof( AccelerationStructureKHR ) == sizeof( VkAccelerationStructureKHR ), + static_assert( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR ) == sizeof( VkAccelerationStructureKHR ), "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = AccelerationStructureKHR; + using type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR; }; template <> - struct CppType + struct CppType { - using Type = AccelerationStructureKHR; + using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; using AccelerationStructureNV = AccelerationStructureKHR; @@ -17919,7 +17941,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkBuffer; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eBuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer; public: VULKAN_HPP_CONSTEXPR Buffer() VULKAN_HPP_NOEXCEPT : m_buffer( VK_NULL_HANDLE ) {} @@ -17979,18 +18004,32 @@ namespace VULKAN_HPP_NAMESPACE private: VkBuffer m_buffer; }; - static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::Buffer ) == sizeof( VkBuffer ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = Buffer; + using type = VULKAN_HPP_NAMESPACE::Buffer; }; template <> - struct CppType + struct CppType { - using Type = Buffer; + using Type = VULKAN_HPP_NAMESPACE::Buffer; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::Buffer; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct GeometryTrianglesNV @@ -19274,7 +19313,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkSwapchainKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSwapchainKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR; public: VULKAN_HPP_CONSTEXPR SwapchainKHR() VULKAN_HPP_NOEXCEPT : m_swapchainKHR( VK_NULL_HANDLE ) {} @@ -19336,19 +19378,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkSwapchainKHR m_swapchainKHR; }; - static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::SwapchainKHR ) == sizeof( VkSwapchainKHR ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = SwapchainKHR; + using type = VULKAN_HPP_NAMESPACE::SwapchainKHR; }; template <> - struct CppType + struct CppType { - using Type = SwapchainKHR; + using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; class Semaphore @@ -19356,7 +19412,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkSemaphore; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSemaphore; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore; public: VULKAN_HPP_CONSTEXPR Semaphore() VULKAN_HPP_NOEXCEPT : m_semaphore( VK_NULL_HANDLE ) {} @@ -19416,19 +19475,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkSemaphore m_semaphore; }; - static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::Semaphore ) == sizeof( VkSemaphore ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = Semaphore; + using type = VULKAN_HPP_NAMESPACE::Semaphore; }; template <> - struct CppType + struct CppType { - using Type = Semaphore; + using Type = VULKAN_HPP_NAMESPACE::Semaphore; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::Semaphore; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; class Fence @@ -19436,7 +19509,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkFence; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFence; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eFence; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence; public: VULKAN_HPP_CONSTEXPR Fence() VULKAN_HPP_NOEXCEPT : m_fence( VK_NULL_HANDLE ) {} @@ -19496,18 +19572,31 @@ namespace VULKAN_HPP_NAMESPACE private: VkFence m_fence; }; - static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::Fence ) == sizeof( VkFence ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = Fence; + using type = VULKAN_HPP_NAMESPACE::Fence; }; template <> - struct CppType + struct CppType { - using Type = Fence; + using Type = VULKAN_HPP_NAMESPACE::Fence; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::Fence; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct AcquireNextImageInfoKHR @@ -21517,7 +21606,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkDeviceMemory; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeviceMemory; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory; public: VULKAN_HPP_CONSTEXPR DeviceMemory() VULKAN_HPP_NOEXCEPT : m_deviceMemory( VK_NULL_HANDLE ) {} @@ -21579,19 +21671,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkDeviceMemory m_deviceMemory; }; - static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemory ) == sizeof( VkDeviceMemory ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = DeviceMemory; + using type = VULKAN_HPP_NAMESPACE::DeviceMemory; }; template <> - struct CppType + struct CppType { - using Type = DeviceMemory; + using Type = VULKAN_HPP_NAMESPACE::DeviceMemory; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::DeviceMemory; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct BindAccelerationStructureMemoryInfoKHR @@ -22248,7 +22354,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkImage; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eImage; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage; public: VULKAN_HPP_CONSTEXPR Image() VULKAN_HPP_NOEXCEPT : m_image( VK_NULL_HANDLE ) {} @@ -22308,18 +22417,31 @@ namespace VULKAN_HPP_NAMESPACE private: VkImage m_image; }; - static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::Image ) == sizeof( VkImage ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = Image; + using type = VULKAN_HPP_NAMESPACE::Image; }; template <> - struct CppType + struct CppType { - using Type = Image; + using Type = VULKAN_HPP_NAMESPACE::Image; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::Image; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct BindImageMemoryInfo @@ -25451,7 +25573,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkCommandPool; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool; public: VULKAN_HPP_CONSTEXPR CommandPool() VULKAN_HPP_NOEXCEPT : m_commandPool( VK_NULL_HANDLE ) {} @@ -25513,19 +25638,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkCommandPool m_commandPool; }; - static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::CommandPool ) == sizeof( VkCommandPool ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = CommandPool; + using type = VULKAN_HPP_NAMESPACE::CommandPool; }; template <> - struct CppType + struct CppType { - using Type = CommandPool; + using Type = VULKAN_HPP_NAMESPACE::CommandPool; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::CommandPool; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct CommandBufferAllocateInfo @@ -25637,7 +25776,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkRenderPass; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eRenderPass; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass; public: VULKAN_HPP_CONSTEXPR RenderPass() VULKAN_HPP_NOEXCEPT : m_renderPass( VK_NULL_HANDLE ) {} @@ -25698,19 +25840,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkRenderPass m_renderPass; }; - static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::RenderPass ) == sizeof( VkRenderPass ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = RenderPass; + using type = VULKAN_HPP_NAMESPACE::RenderPass; }; template <> - struct CppType + struct CppType { - using Type = RenderPass; + using Type = VULKAN_HPP_NAMESPACE::RenderPass; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::RenderPass; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; class Framebuffer @@ -25718,7 +25874,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkFramebuffer; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFramebuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer; public: VULKAN_HPP_CONSTEXPR Framebuffer() VULKAN_HPP_NOEXCEPT : m_framebuffer( VK_NULL_HANDLE ) {} @@ -25780,19 +25939,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkFramebuffer m_framebuffer; }; - static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::Framebuffer ) == sizeof( VkFramebuffer ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = Framebuffer; + using type = VULKAN_HPP_NAMESPACE::Framebuffer; }; template <> - struct CppType + struct CppType { - using Type = Framebuffer; + using Type = VULKAN_HPP_NAMESPACE::Framebuffer; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::Framebuffer; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct CommandBufferInheritanceInfo @@ -26322,7 +26495,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkShaderModule; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderModule; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule; public: VULKAN_HPP_CONSTEXPR ShaderModule() VULKAN_HPP_NOEXCEPT : m_shaderModule( VK_NULL_HANDLE ) {} @@ -26384,19 +26560,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkShaderModule m_shaderModule; }; - static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::ShaderModule ) == sizeof( VkShaderModule ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = ShaderModule; + using type = VULKAN_HPP_NAMESPACE::ShaderModule; }; template <> - struct CppType + struct CppType { - using Type = ShaderModule; + using Type = VULKAN_HPP_NAMESPACE::ShaderModule; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::ShaderModule; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct SpecializationMapEntry @@ -26722,7 +26912,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkPipelineLayout; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineLayout; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout; public: VULKAN_HPP_CONSTEXPR PipelineLayout() VULKAN_HPP_NOEXCEPT : m_pipelineLayout( VK_NULL_HANDLE ) {} @@ -26784,19 +26977,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkPipelineLayout m_pipelineLayout; }; - static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::PipelineLayout ) == sizeof( VkPipelineLayout ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = PipelineLayout; + using type = VULKAN_HPP_NAMESPACE::PipelineLayout; }; template <> - struct CppType + struct CppType { - using Type = PipelineLayout; + using Type = VULKAN_HPP_NAMESPACE::PipelineLayout; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::PipelineLayout; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; class Pipeline @@ -26804,7 +27011,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkPipeline; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipeline; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::ePipeline; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline; public: VULKAN_HPP_CONSTEXPR Pipeline() VULKAN_HPP_NOEXCEPT : m_pipeline( VK_NULL_HANDLE ) {} @@ -26864,18 +27074,32 @@ namespace VULKAN_HPP_NAMESPACE private: VkPipeline m_pipeline; }; - static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::Pipeline ) == sizeof( VkPipeline ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = Pipeline; + using type = VULKAN_HPP_NAMESPACE::Pipeline; }; template <> - struct CppType + struct CppType { - using Type = Pipeline; + using Type = VULKAN_HPP_NAMESPACE::Pipeline; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::Pipeline; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct ComputePipelineCreateInfo @@ -27563,7 +27787,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkDescriptorSet; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSet; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet; public: VULKAN_HPP_CONSTEXPR DescriptorSet() VULKAN_HPP_NOEXCEPT : m_descriptorSet( VK_NULL_HANDLE ) {} @@ -27625,19 +27852,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkDescriptorSet m_descriptorSet; }; - static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSet ) == sizeof( VkDescriptorSet ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = DescriptorSet; + using type = VULKAN_HPP_NAMESPACE::DescriptorSet; }; template <> - struct CppType + struct CppType { - using Type = DescriptorSet; + using Type = VULKAN_HPP_NAMESPACE::DescriptorSet; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::DescriptorSet; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct CopyDescriptorSet @@ -29479,7 +29720,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkDeferredOperationKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeferredOperationKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; public: VULKAN_HPP_CONSTEXPR DeferredOperationKHR() VULKAN_HPP_NOEXCEPT : m_deferredOperationKHR( VK_NULL_HANDLE ) {} @@ -29543,20 +29787,26 @@ namespace VULKAN_HPP_NAMESPACE private: VkDeferredOperationKHR m_deferredOperationKHR; }; - static_assert( sizeof( DeferredOperationKHR ) == sizeof( VkDeferredOperationKHR ), + static_assert( sizeof( VULKAN_HPP_NAMESPACE::DeferredOperationKHR ) == sizeof( VkDeferredOperationKHR ), "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = DeferredOperationKHR; + using type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR; }; template <> - struct CppType + struct CppType { - using Type = DeferredOperationKHR; + using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -29724,7 +29974,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkSampler; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSampler; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eSampler; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler; public: VULKAN_HPP_CONSTEXPR Sampler() VULKAN_HPP_NOEXCEPT : m_sampler( VK_NULL_HANDLE ) {} @@ -29784,18 +30037,32 @@ namespace VULKAN_HPP_NAMESPACE private: VkSampler m_sampler; }; - static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::Sampler ) == sizeof( VkSampler ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = Sampler; + using type = VULKAN_HPP_NAMESPACE::Sampler; }; template <> - struct CppType + struct CppType { - using Type = Sampler; + using Type = VULKAN_HPP_NAMESPACE::Sampler; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::Sampler; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; class ImageView @@ -29803,7 +30070,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkImageView; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImageView; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eImageView; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView; public: VULKAN_HPP_CONSTEXPR ImageView() VULKAN_HPP_NOEXCEPT : m_imageView( VK_NULL_HANDLE ) {} @@ -29863,19 +30133,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkImageView m_imageView; }; - static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::ImageView ) == sizeof( VkImageView ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = ImageView; + using type = VULKAN_HPP_NAMESPACE::ImageView; }; template <> - struct CppType + struct CppType { - using Type = ImageView; + using Type = VULKAN_HPP_NAMESPACE::ImageView; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::ImageView; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct DescriptorImageInfo @@ -30251,7 +30535,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkDescriptorPool; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool; public: VULKAN_HPP_CONSTEXPR DescriptorPool() VULKAN_HPP_NOEXCEPT : m_descriptorPool( VK_NULL_HANDLE ) {} @@ -30313,19 +30600,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkDescriptorPool m_descriptorPool; }; - static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPool ) == sizeof( VkDescriptorPool ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = DescriptorPool; + using type = VULKAN_HPP_NAMESPACE::DescriptorPool; }; template <> - struct CppType + struct CppType { - using Type = DescriptorPool; + using Type = VULKAN_HPP_NAMESPACE::DescriptorPool; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::DescriptorPool; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; class DescriptorSetLayout @@ -30333,7 +30634,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkDescriptorSetLayout; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSetLayout; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout; public: VULKAN_HPP_CONSTEXPR DescriptorSetLayout() VULKAN_HPP_NOEXCEPT : m_descriptorSetLayout( VK_NULL_HANDLE ) {} @@ -30397,20 +30701,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkDescriptorSetLayout m_descriptorSetLayout; }; - static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), + static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = DescriptorSetLayout; + using type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout; }; template <> - struct CppType + struct CppType { - using Type = DescriptorSetLayout; + using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct DescriptorSetAllocateInfo @@ -32800,7 +33117,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkDisplayKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR; public: VULKAN_HPP_CONSTEXPR DisplayKHR() VULKAN_HPP_NOEXCEPT : m_displayKHR( VK_NULL_HANDLE ) {} @@ -32861,19 +33181,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkDisplayKHR m_displayKHR; }; - static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::DisplayKHR ) == sizeof( VkDisplayKHR ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = DisplayKHR; + using type = VULKAN_HPP_NAMESPACE::DisplayKHR; }; template <> - struct CppType + struct CppType { - using Type = DisplayKHR; + using Type = VULKAN_HPP_NAMESPACE::DisplayKHR; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::DisplayKHR; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct PerformanceConfigurationAcquireInfoINTEL @@ -32972,7 +33306,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkPerformanceConfigurationINTEL; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePerformanceConfigurationINTEL; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; public: VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() VULKAN_HPP_NOEXCEPT @@ -33040,20 +33377,27 @@ namespace VULKAN_HPP_NAMESPACE private: VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL; }; - static_assert( sizeof( PerformanceConfigurationINTEL ) == sizeof( VkPerformanceConfigurationINTEL ), + static_assert( sizeof( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL ) == + sizeof( VkPerformanceConfigurationINTEL ), "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = PerformanceConfigurationINTEL; + using type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL; }; template <> - struct CppType + struct CppType { - using Type = PerformanceConfigurationINTEL; + using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; class QueryPool @@ -33061,7 +33405,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkQueryPool; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueryPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool; public: VULKAN_HPP_CONSTEXPR QueryPool() VULKAN_HPP_NOEXCEPT : m_queryPool( VK_NULL_HANDLE ) {} @@ -33121,19 +33468,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkQueryPool m_queryPool; }; - static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::QueryPool ) == sizeof( VkQueryPool ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = QueryPool; + using type = VULKAN_HPP_NAMESPACE::QueryPool; }; template <> - struct CppType + struct CppType { - using Type = QueryPool; + using Type = VULKAN_HPP_NAMESPACE::QueryPool; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::QueryPool; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct RenderPassBeginInfo @@ -33718,7 +34079,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkIndirectCommandsLayoutNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; public: VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV() VULKAN_HPP_NOEXCEPT : m_indirectCommandsLayoutNV( VK_NULL_HANDLE ) @@ -33784,20 +34148,26 @@ namespace VULKAN_HPP_NAMESPACE private: VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV; }; - static_assert( sizeof( IndirectCommandsLayoutNV ) == sizeof( VkIndirectCommandsLayoutNV ), + static_assert( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV ) == sizeof( VkIndirectCommandsLayoutNV ), "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = IndirectCommandsLayoutNV; + using type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV; }; template <> - struct CppType + struct CppType { - using Type = IndirectCommandsLayoutNV; + using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct IndirectCommandsStreamNV @@ -34378,7 +34748,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkBufferView; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferView; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eBufferView; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView; public: VULKAN_HPP_CONSTEXPR BufferView() VULKAN_HPP_NOEXCEPT : m_bufferView( VK_NULL_HANDLE ) {} @@ -34439,19 +34812,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkBufferView m_bufferView; }; - static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::BufferView ) == sizeof( VkBufferView ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = BufferView; + using type = VULKAN_HPP_NAMESPACE::BufferView; }; template <> - struct CppType + struct CppType { - using Type = BufferView; + using Type = VULKAN_HPP_NAMESPACE::BufferView; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::BufferView; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct WriteDescriptorSet @@ -34686,7 +35073,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkDescriptorUpdateTemplate; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorUpdateTemplate; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate; public: VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() VULKAN_HPP_NOEXCEPT : m_descriptorUpdateTemplate( VK_NULL_HANDLE ) @@ -34752,20 +35142,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkDescriptorUpdateTemplate m_descriptorUpdateTemplate; }; - static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), + static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = DescriptorUpdateTemplate; + using type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate; }; template <> - struct CppType + struct CppType { - using Type = DescriptorUpdateTemplate; + using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; @@ -34774,7 +35177,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkEvent; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eEvent; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eEvent; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent; public: VULKAN_HPP_CONSTEXPR Event() VULKAN_HPP_NOEXCEPT : m_event( VK_NULL_HANDLE ) {} @@ -34834,18 +35240,31 @@ namespace VULKAN_HPP_NAMESPACE private: VkEvent m_event; }; - static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::Event ) == sizeof( VkEvent ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = Event; + using type = VULKAN_HPP_NAMESPACE::Event; }; template <> - struct CppType + struct CppType { - using Type = Event; + using Type = VULKAN_HPP_NAMESPACE::Event; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::Event; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct ImageResolve @@ -35563,7 +35982,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkCommandBuffer; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandBuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer; public: VULKAN_HPP_CONSTEXPR CommandBuffer() VULKAN_HPP_NOEXCEPT : m_commandBuffer( VK_NULL_HANDLE ) {} @@ -37383,19 +37805,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkCommandBuffer m_commandBuffer; }; - static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::CommandBuffer ) == sizeof( VkCommandBuffer ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = CommandBuffer; + using type = VULKAN_HPP_NAMESPACE::CommandBuffer; }; template <> - struct CppType + struct CppType { - using Type = CommandBuffer; + using Type = VULKAN_HPP_NAMESPACE::CommandBuffer; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::CommandBuffer; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct MemoryAllocateInfo @@ -37495,7 +37931,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkPipelineCache; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineCache; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache; public: VULKAN_HPP_CONSTEXPR PipelineCache() VULKAN_HPP_NOEXCEPT : m_pipelineCache( VK_NULL_HANDLE ) {} @@ -37557,19 +37996,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkPipelineCache m_pipelineCache; }; - static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::PipelineCache ) == sizeof( VkPipelineCache ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = PipelineCache; + using type = VULKAN_HPP_NAMESPACE::PipelineCache; }; template <> - struct CppType + struct CppType { - using Type = PipelineCache; + using Type = VULKAN_HPP_NAMESPACE::PipelineCache; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::PipelineCache; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct EventCreateInfo @@ -41291,7 +41744,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkPrivateDataSlotEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePrivateDataSlotEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlotEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; public: VULKAN_HPP_CONSTEXPR PrivateDataSlotEXT() VULKAN_HPP_NOEXCEPT : m_privateDataSlotEXT( VK_NULL_HANDLE ) {} @@ -41355,20 +41811,26 @@ namespace VULKAN_HPP_NAMESPACE private: VkPrivateDataSlotEXT m_privateDataSlotEXT; }; - static_assert( sizeof( PrivateDataSlotEXT ) == sizeof( VkPrivateDataSlotEXT ), + static_assert( sizeof( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT ) == sizeof( VkPrivateDataSlotEXT ), "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = PrivateDataSlotEXT; + using type = VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT; }; template <> - struct CppType + struct CppType { - using Type = PrivateDataSlotEXT; + using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct QueryPoolCreateInfo @@ -44062,7 +44524,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkSamplerYcbcrConversion; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSamplerYcbcrConversion; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion; public: VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() VULKAN_HPP_NOEXCEPT : m_samplerYcbcrConversion( VK_NULL_HANDLE ) {} @@ -44127,20 +44592,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkSamplerYcbcrConversion m_samplerYcbcrConversion; }; - static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), + static_assert( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = SamplerYcbcrConversion; + using type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion; }; template <> - struct CppType + struct CppType { - using Type = SamplerYcbcrConversion; + using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; using SamplerYcbcrConversionKHR = SamplerYcbcrConversion; @@ -44350,7 +44828,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkSurfaceKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSurfaceKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR; public: VULKAN_HPP_CONSTEXPR SurfaceKHR() VULKAN_HPP_NOEXCEPT : m_surfaceKHR( VK_NULL_HANDLE ) {} @@ -44411,19 +44892,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkSurfaceKHR m_surfaceKHR; }; - static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::SurfaceKHR ) == sizeof( VkSurfaceKHR ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = SurfaceKHR; + using type = VULKAN_HPP_NAMESPACE::SurfaceKHR; }; template <> - struct CppType + struct CppType { - using Type = SurfaceKHR; + using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct SwapchainCreateInfoKHR @@ -44849,7 +45344,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkValidationCacheEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eValidationCacheEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT; public: VULKAN_HPP_CONSTEXPR ValidationCacheEXT() VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( VK_NULL_HANDLE ) {} @@ -44913,20 +45411,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkValidationCacheEXT m_validationCacheEXT; }; - static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), + static_assert( sizeof( VULKAN_HPP_NAMESPACE::ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = ValidationCacheEXT; + using type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT; }; template <> - struct CppType + struct CppType { - using Type = ValidationCacheEXT; + using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct DisplayPowerInfoEXT @@ -45924,7 +46435,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkQueue; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueue; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eQueue; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue; public: VULKAN_HPP_CONSTEXPR Queue() VULKAN_HPP_NOEXCEPT : m_queue( VK_NULL_HANDLE ) {} @@ -46091,18 +46605,31 @@ namespace VULKAN_HPP_NAMESPACE private: VkQueue m_queue; }; - static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::Queue ) == sizeof( VkQueue ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = Queue; + using type = VULKAN_HPP_NAMESPACE::Queue; }; template <> - struct CppType + struct CppType { - using Type = Queue; + using Type = VULKAN_HPP_NAMESPACE::Queue; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::Queue; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct DeviceQueueInfo2 @@ -49994,7 +50521,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkDevice; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDevice; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eDevice; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice; public: VULKAN_HPP_CONSTEXPR Device() VULKAN_HPP_NOEXCEPT : m_device( VK_NULL_HANDLE ) {} @@ -53807,18 +54337,32 @@ namespace VULKAN_HPP_NAMESPACE private: VkDevice m_device; }; - static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::Device ) == sizeof( VkDevice ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = Device; + using type = VULKAN_HPP_NAMESPACE::Device; }; template <> - struct CppType + struct CppType { - using Type = Device; + using Type = VULKAN_HPP_NAMESPACE::Device; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::Device; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct DisplayModeParametersKHR @@ -53986,7 +54530,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkDisplayModeKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayModeKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR; public: VULKAN_HPP_CONSTEXPR DisplayModeKHR() VULKAN_HPP_NOEXCEPT : m_displayModeKHR( VK_NULL_HANDLE ) {} @@ -54048,19 +54595,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkDisplayModeKHR m_displayModeKHR; }; - static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = DisplayModeKHR; + using type = VULKAN_HPP_NAMESPACE::DisplayModeKHR; }; template <> - struct CppType + struct CppType { - using Type = DisplayModeKHR; + using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct ExtensionProperties @@ -58146,7 +58707,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkPhysicalDevice; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePhysicalDevice; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice; public: VULKAN_HPP_CONSTEXPR PhysicalDevice() VULKAN_HPP_NOEXCEPT : m_physicalDevice( VK_NULL_HANDLE ) {} @@ -59317,19 +59881,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkPhysicalDevice m_physicalDevice; }; - static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice ) == sizeof( VkPhysicalDevice ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = PhysicalDevice; + using type = VULKAN_HPP_NAMESPACE::PhysicalDevice; }; template <> - struct CppType + struct CppType { - using Type = PhysicalDevice; + using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; struct DeviceGroupDeviceCreateInfo @@ -85742,7 +86320,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkDebugReportCallbackEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugReportCallbackEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT; public: VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() VULKAN_HPP_NOEXCEPT : m_debugReportCallbackEXT( VK_NULL_HANDLE ) {} @@ -85807,20 +86388,33 @@ namespace VULKAN_HPP_NAMESPACE private: VkDebugReportCallbackEXT m_debugReportCallbackEXT; }; - static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), + static_assert( sizeof( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = DebugReportCallbackEXT; + using type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT; }; template <> - struct CppType + struct CppType { - using Type = DebugReportCallbackEXT; + using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; class DebugUtilsMessengerEXT @@ -85828,7 +86422,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkDebugUtilsMessengerEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugUtilsMessengerEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; public: VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() VULKAN_HPP_NOEXCEPT : m_debugUtilsMessengerEXT( VK_NULL_HANDLE ) {} @@ -85893,20 +86490,26 @@ namespace VULKAN_HPP_NAMESPACE private: VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT; }; - static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), + static_assert( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = DebugUtilsMessengerEXT; + using type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT; }; template <> - struct CppType + struct CppType { - using Type = DebugUtilsMessengerEXT; + using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; #ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -85939,7 +86542,10 @@ namespace VULKAN_HPP_NAMESPACE public: using CType = VkInstance; - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eInstance; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = + VULKAN_HPP_NAMESPACE::ObjectType::eInstance; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance; public: VULKAN_HPP_CONSTEXPR Instance() VULKAN_HPP_NOEXCEPT : m_instance( VK_NULL_HANDLE ) {} @@ -86567,18 +87173,32 @@ namespace VULKAN_HPP_NAMESPACE private: VkInstance m_instance; }; - static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" ); + static_assert( sizeof( VULKAN_HPP_NAMESPACE::Instance ) == sizeof( VkInstance ), + "handle and wrapper have different size!" ); template <> struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type { - using type = Instance; + using type = VULKAN_HPP_NAMESPACE::Instance; }; template <> - struct CppType + struct CppType { - using Type = Instance; + using Type = VULKAN_HPP_NAMESPACE::Instance; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::Instance; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; #ifndef VULKAN_HPP_NO_SMART_HANDLE