diff --git a/RAII_Samples/CreateDebugUtilsMessenger/CreateDebugUtilsMessenger.cpp b/RAII_Samples/CreateDebugUtilsMessenger/CreateDebugUtilsMessenger.cpp index 2ff5ebc..33127fc 100644 --- a/RAII_Samples/CreateDebugUtilsMessenger/CreateDebugUtilsMessenger.cpp +++ b/RAII_Samples/CreateDebugUtilsMessenger/CreateDebugUtilsMessenger.cpp @@ -24,15 +24,14 @@ static char const * AppName = "CreateDebugReportMessenger"; static char const * EngineName = "Vulkan.hpp"; -VKAPI_ATTR VkBool32 VKAPI_CALL debugMessageFunc( VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - VkDebugUtilsMessengerCallbackDataEXT const * pCallbackData, +VKAPI_ATTR VkBool32 VKAPI_CALL debugMessageFunc( vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + vk::DebugUtilsMessageTypeFlagsEXT messageTypes, + vk::DebugUtilsMessengerCallbackDataEXT const * pCallbackData, void * /*pUserData*/ ) { std::ostringstream message; - message << vk::to_string( static_cast( messageSeverity ) ) << ": " - << vk::to_string( static_cast( messageTypes ) ) << ":\n"; + message << vk::to_string( messageSeverity ) << ": " << vk::to_string( messageTypes ) << ":\n"; message << std::string( "\t" ) << "messageIDName = <" << pCallbackData->pMessageIdName << ">\n"; message << std::string( "\t" ) << "messageIdNumber = " << pCallbackData->messageIdNumber << "\n"; message << std::string( "\t" ) << "message = <" << pCallbackData->pMessage << ">\n"; @@ -58,7 +57,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL debugMessageFunc( VkDebugUtilsMessageSeverityFlag for ( uint32_t i = 0; i < pCallbackData->objectCount; i++ ) { message << std::string( "\t\t" ) << "Object " << i << "\n"; - message << std::string( "\t\t\t" ) << "objectType = " << vk::to_string( static_cast( pCallbackData->pObjects[i].objectType ) ) << "\n"; + message << std::string( "\t\t\t" ) << "objectType = " << vk::to_string( pCallbackData->pObjects[i].objectType ) << "\n"; message << std::string( "\t\t\t" ) << "objectHandle = " << pCallbackData->pObjects[i].objectHandle << "\n"; if ( pCallbackData->pObjects[i].pObjectName ) { diff --git a/RAII_Samples/EnableValidationWithCallback/EnableValidationWithCallback.cpp b/RAII_Samples/EnableValidationWithCallback/EnableValidationWithCallback.cpp index 43dfcf4..e95483e 100644 --- a/RAII_Samples/EnableValidationWithCallback/EnableValidationWithCallback.cpp +++ b/RAII_Samples/EnableValidationWithCallback/EnableValidationWithCallback.cpp @@ -51,15 +51,14 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( VkInstance instance, return pfnVkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator ); } -VKAPI_ATTR VkBool32 VKAPI_CALL debugMessageFunc( VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - VkDebugUtilsMessengerCallbackDataEXT const * pCallbackData, +VKAPI_ATTR VkBool32 VKAPI_CALL debugMessageFunc( vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + vk::DebugUtilsMessageTypeFlagsEXT messageTypes, + vk::DebugUtilsMessengerCallbackDataEXT const * pCallbackData, void * /*pUserData*/ ) { std::string message; - message += vk::to_string( static_cast( messageSeverity ) ) + ": " + - vk::to_string( static_cast( messageTypes ) ) + ":\n"; + message += vk::to_string( messageSeverity ) + ": " + vk::to_string( messageTypes ) + ":\n"; message += std::string( "\t" ) + "messageIDName = <" + pCallbackData->pMessageIdName + ">\n"; message += std::string( "\t" ) + "messageIdNumber = " + std::to_string( pCallbackData->messageIdNumber ) + "\n"; message += std::string( "\t" ) + "message = <" + pCallbackData->pMessage + ">\n"; @@ -84,7 +83,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL debugMessageFunc( VkDebugUtilsMessageSeverityFlag for ( uint32_t i = 0; i < pCallbackData->objectCount; i++ ) { message += std::string( "\t" ) + "Object " + std::to_string( i ) + "\n"; - message += std::string( "\t\t" ) + "objectType = " + vk::to_string( static_cast( pCallbackData->pObjects[i].objectType ) ) + "\n"; + message += std::string( "\t\t" ) + "objectType = " + vk::to_string( pCallbackData->pObjects[i].objectType ) + "\n"; message += std::string( "\t\t" ) + "objectHandle = " + std::to_string( pCallbackData->pObjects[i].objectHandle ) + "\n"; if ( pCallbackData->pObjects[i].pObjectName ) { diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index 408570d..7a1991d 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -1395,7 +1395,7 @@ void VulkanHppGenerator::checkFuncPointerCorrectness() const } for ( auto const & argument : funcPointer.second.arguments ) { - checkForError( m_types.contains( argument.type ), argument.xmlLine, "funcpointer argument of unknown type <" + argument.type + ">" ); + checkForError( m_types.contains( argument.type.type ), argument.xmlLine, "funcpointer argument of unknown type <" + argument.type.type + ">" ); } } } @@ -6729,6 +6729,269 @@ std::string VulkanHppGenerator::generateDecoratedReturnType( CommandData const & return decoratedReturnType; } +std::string VulkanHppGenerator::generateDeprecatedConstructors( std::string const & name ) const +{ + std::string str; + if ( name == "VkAllocationCallbacks" ) + { + // To be removed around December 2025 + str = R"( +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +#endif + VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) + AllocationCallbacks( void * pUserData_, + PFN_vkAllocationFunction pfnAllocation_, + PFN_vkReallocationFunction pfnReallocation_ = {}, + PFN_vkFreeFunction pfnFree_ = {}, + PFN_vkInternalAllocationNotification pfnInternalAllocation_ = {}, + PFN_vkInternalFreeNotification pfnInternalFree_ = {} ) VULKAN_HPP_NOEXCEPT + : AllocationCallbacks( pUserData_, + reinterpret_cast( pfnAllocation_ ), + reinterpret_cast( pfnReallocation_ ), + reinterpret_cast( pfnFree_ ), + reinterpret_cast( pfnInternalAllocation_ ), + reinterpret_cast( pfnInternalFree_ ) ) + { + } +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +#endif +)"; + } + else if ( name == "VkDebugReportCallbackCreateInfoEXT" ) + { + // To be removed around December 2025 + str = R"( +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +#endif + VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) + DebugReportCallbackCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags_, + PFN_vkDebugReportCallbackEXT pfnCallback_, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : DebugReportCallbackCreateInfoEXT( flags_, reinterpret_cast( pfnCallback_ ), pUserData_, pNext_ ) + { + } +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +#endif +)"; + } + else if ( name == "VkDebugUtilsMessengerCreateInfoEXT" ) + { + // To be removed around December 2025 + str = R"( +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +#endif + VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) + DebugUtilsMessengerCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT flags_, + VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT messageSeverity_, + VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType_, + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : DebugUtilsMessengerCreateInfoEXT( flags_, messageSeverity_, messageType_, reinterpret_cast( pfnUserCallback_ ), pUserData_, pNext_ ) + { + } +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +#endif +)"; + } + else if ( name == "VkDeviceDeviceMemoryReportCreateInfoEXT" ) + { + // To be removed around December 2025 + str = R"( +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +#endif + VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) + DeviceDeviceMemoryReportCreateInfoEXT( VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags_, + PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback_, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : DeviceDeviceMemoryReportCreateInfoEXT( flags_, reinterpret_cast( pfnUserCallback_ ), pUserData_, pNext_ ) + { + } +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +#endif +)"; + } + else if ( name == "DirectDriverLoadingInfoLUNARG" ) + { + // To be removed around December 2025 + str = R"( +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +#endif + VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) + DirectDriverLoadingInfoLUNARG( VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG flags_, + PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : DirectDriverLoadingInfoLUNARG( flags_, reinterpret_cast( pfnGetInstanceProcAddr_ ), pNext_ ) + { + } +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +#endif +)"; + } + return str; +} + +std::string VulkanHppGenerator::generateDeprecatedStructSetters( std::string const & name ) const +{ + std::string str; + if ( name == "VkAllocationCallbacks" ) + { + // To be removed around December 2025 + str = R"( +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +#endif + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + AllocationCallbacks & setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnAllocation( reinterpret_cast( pfnAllocation_ ) ); + } + + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + AllocationCallbacks & setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnReallocation( reinterpret_cast( pfnReallocation_ ) ); + } + + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + AllocationCallbacks & setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnInternalAllocation( reinterpret_cast( pfnInternalAllocation_ ) ); + } + + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + AllocationCallbacks & setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnInternalFree( reinterpret_cast( pfnInternalFree_ ) ); + } +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +#endif +)"; + } + else if ( name == "VkDebugReportCallbackCreateInfoEXT" ) + { + // To be removed around December 2025 + str = R"( +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +#endif + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + DebugReportCallbackCreateInfoEXT & setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnCallback( reinterpret_cast( pfnCallback_ ) ); + } +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +#endif +)"; + } + else if ( name == "VkDebugUtilsMessengerCreateInfoEXT" ) + { + // To be removed around December 2025 + str = R"( +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +#endif + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + DebugUtilsMessengerCreateInfoEXT & setPfnUserCallback( PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnUserCallback( reinterpret_cast( pfnUserCallback_ ) ); + } +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +#endif +)"; + } + else if ( name == "VkDeviceDeviceMemoryReportCreateInfoEXT" ) + { + // To be removed around December 2025 + str = R"( +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +#endif + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + DeviceDeviceMemoryReportCreateInfoEXT & setPfnUserCallback( PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnUserCallback( reinterpret_cast( pfnUserCallback_ ) ); + } +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +#endif +)"; + } + else if ( name == "DirectDriverLoadingInfoLUNARG" ) + { + // To be removed around December 2025 + str = R"( +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +#endif + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + DirectDriverLoadingInfoLUNARG & setPfnGetInstanceProcAddr( PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnGetInstanceProcAddr( reinterpret_cast( pfnGetInstanceProcAddr_ ) ); + } +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +#endif +)"; + } + return str; +} + std::string VulkanHppGenerator::generateDispatchLoaderDynamic() const { const std::string dispatchLoaderDynamicTemplate = R"( @@ -7956,6 +8219,57 @@ ${widthDivisorCases} { "texelsPerBlockCases", texelsPerBlockCases } } ); } +std::string VulkanHppGenerator::generateFuncPointer( std::pair const & funcPointer, std::set & listedStructs ) const +{ + std::string str; + for ( auto const & argument : funcPointer.second.arguments ) + { + auto typeIt = m_types.find( argument.type.type ); + assert( typeIt != m_types.end() ); + if ( ( typeIt->second.category == TypeCategory::Struct ) || ( typeIt->second.category == TypeCategory::Union ) ) + { + auto structIt = findByNameOrAlias( m_structs, argument.type.type ); + assert( structIt != m_structs.end() ); + if ( !listedStructs.contains( argument.type.type ) ) + { + str += generateStruct( *structIt, listedStructs ); + } + } + else + { + assert( typeIt->second.category != TypeCategory::FuncPointer ); + } + } + + const auto [enter, leave] = generateProtection( getProtectFromType( funcPointer.first ) ); + + std::string funcPointerArguments; + for ( auto const & argument : funcPointer.second.arguments ) + { + funcPointerArguments += argument.type.compose( "VULKAN_HPP_NAMESPACE" ) + " " + argument.name + ", "; + } + assert( !funcPointerArguments.empty() ); + funcPointerArguments.pop_back(); + funcPointerArguments.pop_back(); + + static const std::string funcPointerTemplate = R"( + typedef ${returnType} (VKAPI_PTR *PFN_${funcPointerName}) + ( + ${funcPointerArguments} + ); +)"; + + str += "\n" + enter + + replaceWithMap( funcPointerTemplate, + { { "funcPointerArguments", funcPointerArguments }, + { "funcPointerName", stripPrefix( funcPointer.first, "PFN_vk" ) }, + { "returnType", funcPointer.second.returnType.compose( "VULKAN_HPP_NAMESPACE" ) } } ) + + leave; + + listedStructs.insert( funcPointer.first ); + return str; +} + std::string VulkanHppGenerator::generateFunctionPointerCheck( std::string const & function, std::set const & requiredBy, bool raii ) const { std::string functionPointerCheck; @@ -11045,6 +11359,15 @@ std::string VulkanHppGenerator::generateStruct( std::pairsecond.category == TypeCategory::FuncPointer ) + { + auto funcPtrIt = m_funcPointers.find( member.type.type ); + assert( funcPtrIt != m_funcPointers.end() ); + if ( !listedStructs.contains( member.type.type ) ) + { + str += generateFuncPointer( *funcPtrIt, listedStructs ); + } + } } if ( !structure.second.subStruct.empty() ) @@ -11497,7 +11820,11 @@ std::string VulkanHppGenerator::generateStructConstructorArgument( MemberData co std::string str; if ( ( memberData.name != "pNext" ) && memberData.value.empty() ) { - if ( memberData.arraySizes.empty() ) + if ( memberData.type.type.starts_with( "PFN_vk" ) ) + { + str += "VULKAN_HPP_NAMESPACE::PFN_" + stripPrefix( memberData.type.type, "PFN_vk" ) + " "; + } + else if ( memberData.arraySizes.empty() ) { str += memberData.type.compose( "VULKAN_HPP_NAMESPACE" ) + " "; } @@ -11771,6 +12098,7 @@ std::string VulkanHppGenerator::generateStructure( std::pair assert( member.type.prefix.empty() && member.type.postfix.empty() ); // never encounterd a different case type = member.type.type; } + else if ( member.type.type.starts_with( "PFN_vk" ) ) + { + assert( member.type.prefix.empty() && member.type.postfix.empty() ); // never encounterd a different case + type = "VULKAN_HPP_NAMESPACE::PFN_" + stripPrefix( member.type.type, "PFN_vk" ); + } else if ( member.arraySizes.empty() ) { type = member.type.compose( "VULKAN_HPP_NAMESPACE" ); @@ -12099,8 +12434,10 @@ std::string VulkanHppGenerator::generateStructSetter( std::string const & struct } )"; - std::string memberType = member.arraySizes.empty() ? member.type.compose( "VULKAN_HPP_NAMESPACE" ) - : generateStandardArray( member.type.compose( "VULKAN_HPP_NAMESPACE" ), member.arraySizes ); + std::string memberType = member.type.type.starts_with( "PFN_vk" ) + ? "VULKAN_HPP_NAMESPACE::PFN_" + stripPrefix( member.type.type, "PFN_vk" ) + : ( member.arraySizes.empty() ? member.type.compose( "VULKAN_HPP_NAMESPACE" ) + : generateStandardArray( member.type.compose( "VULKAN_HPP_NAMESPACE" ), member.arraySizes ) ); const bool isReinterpretation = !member.bitCount.empty() && member.type.type.starts_with( "Vk" ); std::string assignment; if ( isReinterpretation ) @@ -15775,6 +16112,17 @@ void VulkanHppGenerator::readTypeFuncpointer( tinyxml2::XMLElement const * eleme std::vector children = getChildElements( element ); checkElements( line, children, { { "name", true } }, { "type" } ); + std::string text = element->GetText(); + assert( text.starts_with( "typedef " ) && text.ends_with( " (VKAPI_PTR *" ) ); + text = stripPostfix( stripPrefix( text, "typedef " ), " (VKAPI_PTR *" ); + TypeInfo returnType; + if ( text.ends_with( "*" ) ) + { + returnType.postfix = "*"; + text = stripPostfix( text, "*" ); + } + returnType.type = text; + std::string require; for ( auto const & attribute : attributes ) { @@ -15795,22 +16143,38 @@ void VulkanHppGenerator::readTypeFuncpointer( tinyxml2::XMLElement const * eleme } else if ( value == "type" ) { - const int argumentLine = child->GetLineNum(); - std::string type = child->GetText(); + const int argumentLine = child->GetLineNum(); + TypeInfo typeInfo; + typeInfo.type = child->GetText(); - auto sibling = child->NextSibling(); - char const * siblingValue = sibling->Value(); - assert( siblingValue != nullptr ); - std::string argumentName = siblingValue; - argumentName = argumentName.substr( argumentName.find_first_not_of( "* " ) ); - argumentName = argumentName.substr( 0, argumentName.find_first_of( ",)" ) ); + auto previousSibling = child->PreviousSibling(); + assert( previousSibling ); + char const * previousSiblingValue = previousSibling->Value(); + assert( previousSiblingValue ); + std::string previousSiblingText = previousSiblingValue; + if ( previousSiblingText.ends_with( "const " ) ) + { + typeInfo.prefix = "const"; + } + + auto nextSibling = child->NextSibling(); + assert( nextSibling ); + char const * nextSiblingValue = nextSibling->Value(); + assert( nextSiblingValue != nullptr ); + std::string argumentName = nextSiblingValue; + if ( argumentName.front() == '*' ) + { + typeInfo.postfix = "*"; + } + argumentName = argumentName.substr( argumentName.find_first_not_of( "* " ) ); + argumentName = argumentName.substr( 0, argumentName.find_first_of( ",)" ) ); checkForError( std::none_of( arguments.begin(), arguments.end(), [&argumentName]( FuncPointerArgumentData const & argument ) { return argument.name == argumentName; } ), line, "argument <" + argumentName + "> already listed in funcpointer <" + name + ">" ); - arguments.push_back( { argumentName, type, argumentLine } ); + arguments.push_back( { argumentName, typeInfo, argumentLine } ); } } assert( !name.empty() ); @@ -15818,7 +16182,7 @@ void VulkanHppGenerator::readTypeFuncpointer( tinyxml2::XMLElement const * eleme std::set argumentNames; checkForError( m_types.insert( { name, TypeData{ TypeCategory::FuncPointer, {}, line } } ).second, line, "funcpointer <" + name + "> already specified" ); assert( !m_funcPointers.contains( name ) ); - m_funcPointers[name] = { arguments, require, line }; + m_funcPointers[name] = { arguments, require, returnType, line }; } void VulkanHppGenerator::readTypeHandle( tinyxml2::XMLElement const * element, std::map const & attributes ) diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index e5ab26b..05a5b0c 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -337,7 +337,7 @@ private: struct FuncPointerArgumentData { std::string name = {}; - std::string type = {}; + TypeInfo type = {}; int xmlLine = {}; }; @@ -345,6 +345,7 @@ private: { std::vector arguments = {}; std::string require = {}; + TypeInfo returnType = {}; int xmlLine = {}; }; @@ -811,6 +812,8 @@ private: CommandFlavourFlags flavourFlags, bool raii, std::string const & returnType ) const; + std::string generateDeprecatedConstructors( std::string const & name ) const; + std::string generateDeprecatedStructSetters( std::string const & name ) const; std::string generateDispatchLoaderDynamic() const; // uses vkGet*ProcAddress to get function pointers std::string generateDispatchLoaderStatic() const; // uses exported symbols from loader std::string generateDestroyCommand( std::string const & name, CommandData const & commandData ) const; @@ -840,6 +843,7 @@ private: std::string generateExtensionsList( std::string const & type ) const; std::string generateExtensionTypeTest( std::string const & type ) const; std::string generateFormatTraits() const; + std::string generateFuncPointer( std::pair const & funcPointer, std::set & listedStructs ) const; std::string generateFunctionPointerCheck( std::string const & function, std::set const & requiredBy, bool raii ) const; std::string generateHandle( std::pair const & handle, std::set & listedHandles ) const; std::string generateHandleCommandDeclarations( std::set const & commands ) const; diff --git a/samples/CreateDebugUtilsMessenger/CreateDebugUtilsMessenger.cpp b/samples/CreateDebugUtilsMessenger/CreateDebugUtilsMessenger.cpp index 5ca48dc..ee2b63d 100644 --- a/samples/CreateDebugUtilsMessenger/CreateDebugUtilsMessenger.cpp +++ b/samples/CreateDebugUtilsMessenger/CreateDebugUtilsMessenger.cpp @@ -39,15 +39,14 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( VkInstance instance, return pfnVkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator ); } -VKAPI_ATTR VkBool32 VKAPI_CALL debugMessageFunc( VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - VkDebugUtilsMessengerCallbackDataEXT const * pCallbackData, - void * /*pUserData*/ ) +VKAPI_ATTR vk::Bool32 VKAPI_CALL debugMessageFunc( vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + vk::DebugUtilsMessageTypeFlagsEXT messageTypes, + vk::DebugUtilsMessengerCallbackDataEXT const * pCallbackData, + void * /*pUserData*/ ) { std::ostringstream message; - message << vk::to_string( static_cast( messageSeverity ) ) << ": " - << vk::to_string( static_cast( messageTypes ) ) << ":\n"; + message << vk::to_string( messageSeverity ) << ": " << vk::to_string( messageTypes ) << ":\n"; message << std::string( "\t" ) << "messageIDName = <" << pCallbackData->pMessageIdName << ">\n"; message << std::string( "\t" ) << "messageIdNumber = " << pCallbackData->messageIdNumber << "\n"; message << std::string( "\t" ) << "message = <" << pCallbackData->pMessage << ">\n"; @@ -73,7 +72,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL debugMessageFunc( VkDebugUtilsMessageSeverityFlag for ( uint32_t i = 0; i < pCallbackData->objectCount; i++ ) { message << std::string( "\t\t" ) << "Object " << i << "\n"; - message << std::string( "\t\t\t" ) << "objectType = " << vk::to_string( static_cast( pCallbackData->pObjects[i].objectType ) ) << "\n"; + message << std::string( "\t\t\t" ) << "objectType = " << vk::to_string( pCallbackData->pObjects[i].objectType ) << "\n"; message << std::string( "\t\t\t" ) << "objectHandle = " << pCallbackData->pObjects[i].objectHandle << "\n"; if ( pCallbackData->pObjects[i].pObjectName ) { diff --git a/samples/EnableValidationWithCallback/EnableValidationWithCallback.cpp b/samples/EnableValidationWithCallback/EnableValidationWithCallback.cpp index c5bc0bb..86ee595 100644 --- a/samples/EnableValidationWithCallback/EnableValidationWithCallback.cpp +++ b/samples/EnableValidationWithCallback/EnableValidationWithCallback.cpp @@ -51,15 +51,14 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( VkInstance instance, return pfnVkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator ); } -VKAPI_ATTR VkBool32 VKAPI_CALL debugMessageFunc( VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - VkDebugUtilsMessengerCallbackDataEXT const * pCallbackData, +VKAPI_ATTR VkBool32 VKAPI_CALL debugMessageFunc( vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + vk::DebugUtilsMessageTypeFlagsEXT messageTypes, + vk::DebugUtilsMessengerCallbackDataEXT const * pCallbackData, void * /*pUserData*/ ) { std::string message; - message += vk::to_string( static_cast( messageSeverity ) ) + ": " + - vk::to_string( static_cast( messageTypes ) ) + ":\n"; + message += vk::to_string( messageSeverity ) + ": " + vk::to_string( messageTypes ) + ":\n"; message += std::string( "\t" ) + "messageIDName = <" + pCallbackData->pMessageIdName + ">\n"; message += std::string( "\t" ) + "messageIdNumber = " + std::to_string( pCallbackData->messageIdNumber ) + "\n"; message += std::string( "\t" ) + "message = <" + pCallbackData->pMessage + ">\n"; @@ -84,7 +83,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL debugMessageFunc( VkDebugUtilsMessageSeverityFlag for ( uint32_t i = 0; i < pCallbackData->objectCount; i++ ) { message += std::string( "\t" ) + "Object " + std::to_string( i ) + "\n"; - message += std::string( "\t\t" ) + "objectType = " + vk::to_string( static_cast( pCallbackData->pObjects[i].objectType ) ) + "\n"; + message += std::string( "\t\t" ) + "objectType = " + vk::to_string( pCallbackData->pObjects[i].objectType ) + "\n"; message += std::string( "\t\t" ) + "objectHandle = " + std::to_string( pCallbackData->pObjects[i].objectHandle ) + "\n"; if ( pCallbackData->pObjects[i].pObjectName ) { diff --git a/samples/utils/utils.cpp b/samples/utils/utils.cpp index eada913..681f192 100644 --- a/samples/utils/utils.cpp +++ b/samples/utils/utils.cpp @@ -348,10 +348,10 @@ namespace vk return device.createRenderPass( vk::RenderPassCreateInfo( vk::RenderPassCreateFlags(), attachmentDescriptions, subpassDescription ) ); } - VKAPI_ATTR VkBool32 VKAPI_CALL debugUtilsMessengerCallback( VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - VkDebugUtilsMessengerCallbackDataEXT const * pCallbackData, - void * /*pUserData*/ ) + VKAPI_ATTR vk::Bool32 VKAPI_CALL debugUtilsMessengerCallback( vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + vk::DebugUtilsMessageTypeFlagsEXT messageTypes, + const vk::DebugUtilsMessengerCallbackDataEXT * pCallbackData, + void * /*pUserData*/ ) { #if !defined( NDEBUG ) switch ( static_cast( pCallbackData->messageIdNumber ) ) @@ -369,8 +369,7 @@ namespace vk } #endif - std::cerr << vk::to_string( static_cast( messageSeverity ) ) << ": " - << vk::to_string( static_cast( messageTypes ) ) << ":\n"; + std::cerr << vk::to_string( messageSeverity ) << ": " << vk::to_string( messageTypes ) << ":\n"; std::cerr << std::string( "\t" ) << "messageIDName = <" << pCallbackData->pMessageIdName << ">\n"; std::cerr << std::string( "\t" ) << "messageIdNumber = " << pCallbackData->messageIdNumber << "\n"; std::cerr << std::string( "\t" ) << "message = <" << pCallbackData->pMessage << ">\n"; @@ -396,8 +395,7 @@ namespace vk for ( uint32_t i = 0; i < pCallbackData->objectCount; i++ ) { std::cerr << std::string( "\t\t" ) << "Object " << i << "\n"; - std::cerr << std::string( "\t\t\t" ) << "objectType = " << vk::to_string( static_cast( pCallbackData->pObjects[i].objectType ) ) - << "\n"; + std::cerr << std::string( "\t\t\t" ) << "objectType = " << vk::to_string( pCallbackData->pObjects[i].objectType ) << "\n"; std::cerr << std::string( "\t\t\t" ) << "objectHandle = " << pCallbackData->pObjects[i].objectHandle << "\n"; if ( pCallbackData->pObjects[i].pObjectName ) { @@ -422,7 +420,7 @@ namespace vk std::pair findGraphicsAndPresentQueueFamilyIndex( vk::PhysicalDevice physicalDevice, vk::SurfaceKHR const & surface ) { std::vector queueFamilyProperties = physicalDevice.getQueueFamilyProperties(); - assert( queueFamilyProperties.size() < (std::numeric_limits::max)() ); + assert( queueFamilyProperties.size() < ( std::numeric_limits::max )() ); uint32_t graphicsQueueFamilyIndex = findGraphicsQueueFamilyIndex( queueFamilyProperties ); if ( physicalDevice.getSurfaceSupportKHR( graphicsQueueFamilyIndex, surface ) ) @@ -802,7 +800,7 @@ namespace vk vk::SurfaceCapabilitiesKHR surfaceCapabilities = physicalDevice.getSurfaceCapabilitiesKHR( surface ); vk::Extent2D swapchainExtent; - if ( surfaceCapabilities.currentExtent.width == (std::numeric_limits::max)() ) + if ( surfaceCapabilities.currentExtent.width == ( std::numeric_limits::max )() ) { // If the surface size is undefined, the size is set to the size of the images requested. swapchainExtent.width = clamp( extent.width, surfaceCapabilities.minImageExtent.width, surfaceCapabilities.maxImageExtent.width ); diff --git a/samples/utils/utils.hpp b/samples/utils/utils.hpp index ee03683..4b93125 100644 --- a/samples/utils/utils.hpp +++ b/samples/utils/utils.hpp @@ -76,10 +76,10 @@ namespace vk VULKAN_HPP_INLINE uint32_t clampSurfaceImageCount( const uint32_t desiredImageCount, const uint32_t minImageCount, const uint32_t maxImageCount ) { - uint32_t imageCount = (std::max)( desiredImageCount, minImageCount ); + uint32_t imageCount = ( std::max )( desiredImageCount, minImageCount ); if ( maxImageCount > 0 ) { - imageCount = (std::min)( imageCount, maxImageCount ); + imageCount = ( std::min )( imageCount, maxImageCount ); } return imageCount; } @@ -355,55 +355,55 @@ namespace vk static_assert( !std::numeric_limits::is_signed, "Only unsigned types supported!" ); static_assert( std::numeric_limits::is_integer, "Only integer types supported!" ); static_assert( !std::numeric_limits::is_signed, "Only unsigned types supported!" ); - assert( value <= (std::numeric_limits::max)() ); + assert( value <= ( std::numeric_limits::max )() ); return static_cast( value ); } - vk::DeviceMemory allocateDeviceMemory( vk::Device const & device, - vk::PhysicalDeviceMemoryProperties const & memoryProperties, - vk::MemoryRequirements const & memoryRequirements, - vk::MemoryPropertyFlags memoryPropertyFlags ); - bool contains( std::vector const & extensionProperties, std::string const & extensionName ); - vk::DescriptorPool createDescriptorPool( vk::Device const & device, std::vector const & poolSizes ); - vk::DescriptorSetLayout createDescriptorSetLayout( vk::Device const & device, - std::vector> const & bindingData, - vk::DescriptorSetLayoutCreateFlags flags = {} ); - vk::Device createDevice( vk::PhysicalDevice const & physicalDevice, - uint32_t queueFamilyIndex, - std::vector const & extensions = {}, - vk::PhysicalDeviceFeatures const * physicalDeviceFeatures = nullptr, - void const * pNext = nullptr ); - std::vector createFramebuffers( vk::Device const & device, - vk::RenderPass & renderPass, - std::vector const & imageViews, - vk::ImageView const & depthImageView, - vk::Extent2D const & extent ); - vk::Pipeline createGraphicsPipeline( vk::Device const & device, - vk::PipelineCache const & pipelineCache, - std::pair const & vertexShaderData, - std::pair const & fragmentShaderData, - uint32_t vertexStride, - std::vector> const & vertexInputAttributeFormatOffset, - vk::FrontFace frontFace, - bool depthBuffered, - vk::PipelineLayout const & pipelineLayout, - vk::RenderPass const & renderPass ); - vk::Instance createInstance( std::string const & appName, - std::string const & engineName, - std::vector const & layers = {}, - std::vector const & extensions = {}, - uint32_t apiVersion = VK_API_VERSION_1_0 ); - vk::RenderPass createRenderPass( vk::Device const & device, - vk::Format colorFormat, - vk::Format depthFormat, - vk::AttachmentLoadOp loadOp = vk::AttachmentLoadOp::eClear, - vk::ImageLayout colorFinalLayout = vk::ImageLayout::ePresentSrcKHR ); - VKAPI_ATTR VkBool32 VKAPI_CALL debugUtilsMessengerCallback( VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - VkDebugUtilsMessengerCallbackDataEXT const * pCallbackData, - void * /*pUserData*/ ); - uint32_t findGraphicsQueueFamilyIndex( std::vector const & queueFamilyProperties ); - std::pair findGraphicsAndPresentQueueFamilyIndex( vk::PhysicalDevice physicalDevice, vk::SurfaceKHR const & surface ); + vk::DeviceMemory allocateDeviceMemory( vk::Device const & device, + vk::PhysicalDeviceMemoryProperties const & memoryProperties, + vk::MemoryRequirements const & memoryRequirements, + vk::MemoryPropertyFlags memoryPropertyFlags ); + bool contains( std::vector const & extensionProperties, std::string const & extensionName ); + vk::DescriptorPool createDescriptorPool( vk::Device const & device, std::vector const & poolSizes ); + vk::DescriptorSetLayout createDescriptorSetLayout( vk::Device const & device, + std::vector> const & bindingData, + vk::DescriptorSetLayoutCreateFlags flags = {} ); + vk::Device createDevice( vk::PhysicalDevice const & physicalDevice, + uint32_t queueFamilyIndex, + std::vector const & extensions = {}, + vk::PhysicalDeviceFeatures const * physicalDeviceFeatures = nullptr, + void const * pNext = nullptr ); + std::vector createFramebuffers( vk::Device const & device, + vk::RenderPass & renderPass, + std::vector const & imageViews, + vk::ImageView const & depthImageView, + vk::Extent2D const & extent ); + vk::Pipeline createGraphicsPipeline( vk::Device const & device, + vk::PipelineCache const & pipelineCache, + std::pair const & vertexShaderData, + std::pair const & fragmentShaderData, + uint32_t vertexStride, + std::vector> const & vertexInputAttributeFormatOffset, + vk::FrontFace frontFace, + bool depthBuffered, + vk::PipelineLayout const & pipelineLayout, + vk::RenderPass const & renderPass ); + vk::Instance createInstance( std::string const & appName, + std::string const & engineName, + std::vector const & layers = {}, + std::vector const & extensions = {}, + uint32_t apiVersion = VK_API_VERSION_1_0 ); + vk::RenderPass createRenderPass( vk::Device const & device, + vk::Format colorFormat, + vk::Format depthFormat, + vk::AttachmentLoadOp loadOp = vk::AttachmentLoadOp::eClear, + vk::ImageLayout colorFinalLayout = vk::ImageLayout::ePresentSrcKHR ); + VKAPI_ATTR vk::Bool32 VKAPI_CALL debugUtilsMessengerCallback( vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + vk::DebugUtilsMessageTypeFlagsEXT messageTypes, + vk::DebugUtilsMessengerCallbackDataEXT const * pCallbackData, + void * /*pUserData*/ ); + uint32_t findGraphicsQueueFamilyIndex( std::vector const & queueFamilyProperties ); + std::pair findGraphicsAndPresentQueueFamilyIndex( vk::PhysicalDevice physicalDevice, vk::SurfaceKHR const & surface ); uint32_t findMemoryType( vk::PhysicalDeviceMemoryProperties const & memoryProperties, uint32_t typeBits, vk::MemoryPropertyFlags requirementsMask ); std::vector gatherExtensions( std::vector const & extensions #if !defined( NDEBUG ) diff --git a/vulkan/vulkan_structs.hpp b/vulkan/vulkan_structs.hpp index 054482c..da82a89 100644 --- a/vulkan/vulkan_structs.hpp +++ b/vulkan/vulkan_structs.hpp @@ -4483,17 +4483,37 @@ namespace VULKAN_HPP_NAMESPACE using Type = AcquireProfilingLockInfoKHR; }; + typedef void *( VKAPI_PTR * PFN_AllocationFunction )( void * pUserData, + size_t size, + size_t alignment, + VULKAN_HPP_NAMESPACE::SystemAllocationScope allocationScope ); + + typedef void *( VKAPI_PTR * PFN_ReallocationFunction )( + void * pUserData, void * pOriginal, size_t size, size_t alignment, VULKAN_HPP_NAMESPACE::SystemAllocationScope allocationScope ); + + typedef void( VKAPI_PTR * PFN_FreeFunction )( void * pUserData, void * pMemory ); + + typedef void( VKAPI_PTR * PFN_InternalAllocationNotification )( void * pUserData, + size_t size, + VULKAN_HPP_NAMESPACE::InternalAllocationType allocationType, + VULKAN_HPP_NAMESPACE::SystemAllocationScope allocationScope ); + + typedef void( VKAPI_PTR * PFN_InternalFreeNotification )( void * pUserData, + size_t size, + VULKAN_HPP_NAMESPACE::InternalAllocationType allocationType, + VULKAN_HPP_NAMESPACE::SystemAllocationScope allocationScope ); + struct AllocationCallbacks { using NativeType = VkAllocationCallbacks; #if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AllocationCallbacks( void * pUserData_ = {}, - PFN_vkAllocationFunction pfnAllocation_ = {}, - PFN_vkReallocationFunction pfnReallocation_ = {}, - PFN_vkFreeFunction pfnFree_ = {}, - PFN_vkInternalAllocationNotification pfnInternalAllocation_ = {}, - PFN_vkInternalFreeNotification pfnInternalFree_ = {} ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR AllocationCallbacks( void * pUserData_ = {}, + VULKAN_HPP_NAMESPACE::PFN_AllocationFunction pfnAllocation_ = {}, + VULKAN_HPP_NAMESPACE::PFN_ReallocationFunction pfnReallocation_ = {}, + VULKAN_HPP_NAMESPACE::PFN_FreeFunction pfnFree_ = {}, + VULKAN_HPP_NAMESPACE::PFN_InternalAllocationNotification pfnInternalAllocation_ = {}, + VULKAN_HPP_NAMESPACE::PFN_InternalFreeNotification pfnInternalFree_ = {} ) VULKAN_HPP_NOEXCEPT : pUserData{ pUserData_ } , pfnAllocation{ pfnAllocation_ } , pfnReallocation{ pfnReallocation_ } @@ -4509,6 +4529,33 @@ namespace VULKAN_HPP_NAMESPACE { } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) + + AllocationCallbacks( void * pUserData_, + PFN_vkAllocationFunction pfnAllocation_, + PFN_vkReallocationFunction pfnReallocation_ = {}, + PFN_vkFreeFunction pfnFree_ = {}, + PFN_vkInternalAllocationNotification pfnInternalAllocation_ = {}, + PFN_vkInternalFreeNotification pfnInternalFree_ = {} ) VULKAN_HPP_NOEXCEPT + : AllocationCallbacks( pUserData_, + reinterpret_cast( pfnAllocation_ ), + reinterpret_cast( pfnReallocation_ ), + reinterpret_cast( pfnFree_ ), + reinterpret_cast( pfnInternalAllocation_ ), + reinterpret_cast( pfnInternalFree_ ) ) + { + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif + AllocationCallbacks & operator=( AllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -4525,35 +4572,74 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnAllocation( VULKAN_HPP_NAMESPACE::PFN_AllocationFunction pfnAllocation_ ) VULKAN_HPP_NOEXCEPT { pfnAllocation = pfnAllocation_; return *this; } - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnReallocation( VULKAN_HPP_NAMESPACE::PFN_ReallocationFunction pfnReallocation_ ) VULKAN_HPP_NOEXCEPT { pfnReallocation = pfnReallocation_; return *this; } - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnFree( PFN_vkFreeFunction pfnFree_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnFree( VULKAN_HPP_NAMESPACE::PFN_FreeFunction pfnFree_ ) VULKAN_HPP_NOEXCEPT { pfnFree = pfnFree_; return *this; } - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & + setPfnInternalAllocation( VULKAN_HPP_NAMESPACE::PFN_InternalAllocationNotification pfnInternalAllocation_ ) VULKAN_HPP_NOEXCEPT { pfnInternalAllocation = pfnInternalAllocation_; return *this; } - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnInternalFree( VULKAN_HPP_NAMESPACE::PFN_InternalFreeNotification pfnInternalFree_ ) VULKAN_HPP_NOEXCEPT { pfnInternalFree = pfnInternalFree_; return *this; } + +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + + AllocationCallbacks & setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnAllocation( reinterpret_cast( pfnAllocation_ ) ); + } + + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + + AllocationCallbacks & setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnReallocation( reinterpret_cast( pfnReallocation_ ) ); + } + + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + + AllocationCallbacks & setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnInternalAllocation( reinterpret_cast( pfnInternalAllocation_ ) ); + } + + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + + AllocationCallbacks & setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnInternalFree( reinterpret_cast( pfnInternalFree_ ) ); + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ operator VkAllocationCallbacks const &() const VULKAN_HPP_NOEXCEPT @@ -4571,11 +4657,11 @@ namespace VULKAN_HPP_NAMESPACE auto # else std::tuple + VULKAN_HPP_NAMESPACE::PFN_AllocationFunction const &, + VULKAN_HPP_NAMESPACE::PFN_ReallocationFunction const &, + VULKAN_HPP_NAMESPACE::PFN_FreeFunction const &, + VULKAN_HPP_NAMESPACE::PFN_InternalAllocationNotification const &, + VULKAN_HPP_NAMESPACE::PFN_InternalFreeNotification const &> # endif reflect() const VULKAN_HPP_NOEXCEPT { @@ -4599,12 +4685,12 @@ namespace VULKAN_HPP_NAMESPACE } public: - void * pUserData = {}; - PFN_vkAllocationFunction pfnAllocation = {}; - PFN_vkReallocationFunction pfnReallocation = {}; - PFN_vkFreeFunction pfnFree = {}; - PFN_vkInternalAllocationNotification pfnInternalAllocation = {}; - PFN_vkInternalFreeNotification pfnInternalFree = {}; + void * pUserData = {}; + VULKAN_HPP_NAMESPACE::PFN_AllocationFunction pfnAllocation = {}; + VULKAN_HPP_NAMESPACE::PFN_ReallocationFunction pfnReallocation = {}; + VULKAN_HPP_NAMESPACE::PFN_FreeFunction pfnFree = {}; + VULKAN_HPP_NAMESPACE::PFN_InternalAllocationNotification pfnInternalAllocation = {}; + VULKAN_HPP_NAMESPACE::PFN_InternalFreeNotification pfnInternalFree = {}; }; struct AmigoProfilingSubmitInfoSEC @@ -21679,6 +21765,15 @@ namespace VULKAN_HPP_NAMESPACE using Type = DebugMarkerObjectTagInfoEXT; }; + typedef VULKAN_HPP_NAMESPACE::Bool32( VKAPI_PTR * PFN_DebugReportCallbackEXT )( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char * pLayerPrefix, + const char * pMessage, + void * pUserData ); + struct DebugReportCallbackCreateInfoEXT { using NativeType = VkDebugReportCallbackCreateInfoEXT; @@ -21687,10 +21782,10 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugReportCallbackCreateInfoEXT; #if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags_ = {}, - PFN_vkDebugReportCallbackEXT pfnCallback_ = {}, - void * pUserData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags_ = {}, + VULKAN_HPP_NAMESPACE::PFN_DebugReportCallbackEXT pfnCallback_ = {}, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } , flags{ flags_ } , pfnCallback{ pfnCallback_ } @@ -21705,6 +21800,26 @@ namespace VULKAN_HPP_NAMESPACE { } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) + + DebugReportCallbackCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags_, + PFN_vkDebugReportCallbackEXT pfnCallback_, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : DebugReportCallbackCreateInfoEXT( flags_, reinterpret_cast( pfnCallback_ ), pUserData_, pNext_ ) + { + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif + DebugReportCallbackCreateInfoEXT & operator=( DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -21727,7 +21842,8 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & + setPfnCallback( VULKAN_HPP_NAMESPACE::PFN_DebugReportCallbackEXT pfnCallback_ ) VULKAN_HPP_NOEXCEPT { pfnCallback = pfnCallback_; return *this; @@ -21738,6 +21854,23 @@ namespace VULKAN_HPP_NAMESPACE pUserData = pUserData_; return *this; } + +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + + DebugReportCallbackCreateInfoEXT & setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnCallback( reinterpret_cast( pfnCallback_ ) ); + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ operator VkDebugReportCallbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT @@ -21757,7 +21890,7 @@ namespace VULKAN_HPP_NAMESPACE std::tuple # endif reflect() const VULKAN_HPP_NOEXCEPT @@ -21781,11 +21914,11 @@ namespace VULKAN_HPP_NAMESPACE } public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT; - const void * pNext = {}; - VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags = {}; - PFN_vkDebugReportCallbackEXT pfnCallback = {}; - void * pUserData = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags = {}; + VULKAN_HPP_NAMESPACE::PFN_DebugReportCallbackEXT pfnCallback = {}; + void * pUserData = {}; }; template <> @@ -22313,6 +22446,12 @@ namespace VULKAN_HPP_NAMESPACE using Type = DebugUtilsMessengerCallbackDataEXT; }; + typedef VULKAN_HPP_NAMESPACE::Bool32( VKAPI_PTR * PFN_DebugUtilsMessengerCallbackEXT )( + VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, + const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData, + void * pUserData ); + struct DebugUtilsMessengerCreateInfoEXT { using NativeType = VkDebugUtilsMessengerCreateInfoEXT; @@ -22321,12 +22460,12 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsMessengerCreateInfoEXT; #if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT flags_ = {}, - VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = {}, - VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType_ = {}, - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = {}, - void * pUserData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT flags_ = {}, + VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = {}, + VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType_ = {}, + VULKAN_HPP_NAMESPACE::PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback_ = {}, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } , flags{ flags_ } , messageSeverity{ messageSeverity_ } @@ -22343,6 +22482,33 @@ namespace VULKAN_HPP_NAMESPACE { } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) + + DebugUtilsMessengerCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT flags_, + VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT messageSeverity_, + VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType_, + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : DebugUtilsMessengerCreateInfoEXT( flags_, + messageSeverity_, + messageType_, + reinterpret_cast( pfnUserCallback_ ), + pUserData_, + pNext_ ) + { + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif + DebugUtilsMessengerCreateInfoEXT & operator=( DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -22379,7 +22545,8 @@ namespace VULKAN_HPP_NAMESPACE return *this; } - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setPfnUserCallback( PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & + setPfnUserCallback( VULKAN_HPP_NAMESPACE::PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT { pfnUserCallback = pfnUserCallback_; return *this; @@ -22390,6 +22557,23 @@ namespace VULKAN_HPP_NAMESPACE pUserData = pUserData_; return *this; } + +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + + DebugUtilsMessengerCreateInfoEXT & setPfnUserCallback( PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnUserCallback( reinterpret_cast( pfnUserCallback_ ) ); + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ operator VkDebugUtilsMessengerCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT @@ -22411,7 +22595,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT const &, VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT const &, VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT const &, - PFN_vkDebugUtilsMessengerCallbackEXT const &, + VULKAN_HPP_NAMESPACE::PFN_DebugUtilsMessengerCallbackEXT const &, void * const &> # endif reflect() const VULKAN_HPP_NOEXCEPT @@ -22436,13 +22620,13 @@ namespace VULKAN_HPP_NAMESPACE } public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT; - const void * pNext = {}; - VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT flags = {}; - VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT messageSeverity = {}; - VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType = {}; - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback = {}; - void * pUserData = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT flags = {}; + VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT messageSeverity = {}; + VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType = {}; + VULKAN_HPP_NAMESPACE::PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback = {}; + void * pUserData = {}; }; template <> @@ -27842,6 +28026,120 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceCreateInfo; }; + struct DeviceMemoryReportCallbackDataEXT + { + using NativeType = VkDeviceMemoryReportCallbackDataEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryReportCallbackDataEXT; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceMemoryReportCallbackDataEXT( + VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags_ = {}, + VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT type_ = VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT::eAllocate, + uint64_t memoryObjectId_ = {}, + VULKAN_HPP_NAMESPACE::DeviceSize size_ = {}, + VULKAN_HPP_NAMESPACE::ObjectType objectType_ = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown, + uint64_t objectHandle_ = {}, + uint32_t heapIndex_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , type{ type_ } + , memoryObjectId{ memoryObjectId_ } + , size{ size_ } + , objectType{ objectType_ } + , objectHandle{ objectHandle_ } + , heapIndex{ heapIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceMemoryReportCallbackDataEXT( DeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceMemoryReportCallbackDataEXT( VkDeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceMemoryReportCallbackDataEXT( *reinterpret_cast( &rhs ) ) + { + } + + DeviceMemoryReportCallbackDataEXT & operator=( DeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + DeviceMemoryReportCallbackDataEXT & operator=( VkDeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDeviceMemoryReportCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceMemoryReportCallbackDataEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, type, memoryObjectId, size, objectType, objectHandle, heapIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceMemoryReportCallbackDataEXT const & ) const = default; +#else + bool operator==( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( type == rhs.type ) && ( memoryObjectId == rhs.memoryObjectId ) && + ( size == rhs.size ) && ( objectType == rhs.objectType ) && ( objectHandle == rhs.objectHandle ) && ( heapIndex == rhs.heapIndex ); +# endif + } + + bool operator!=( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceMemoryReportCallbackDataEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags = {}; + VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT type = VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT::eAllocate; + uint64_t memoryObjectId = {}; + VULKAN_HPP_NAMESPACE::DeviceSize size = {}; + VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown; + uint64_t objectHandle = {}; + uint32_t heapIndex = {}; + }; + + template <> + struct CppType + { + using Type = DeviceMemoryReportCallbackDataEXT; + }; + + typedef void( VKAPI_PTR * PFN_DeviceMemoryReportCallbackEXT )( const VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT * pCallbackData, + void * pUserData ); + struct DeviceDeviceMemoryReportCreateInfoEXT { using NativeType = VkDeviceDeviceMemoryReportCreateInfoEXT; @@ -27850,10 +28148,10 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceDeviceMemoryReportCreateInfoEXT; #if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceDeviceMemoryReportCreateInfoEXT( VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags_ = {}, - PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback_ = {}, - void * pUserData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR DeviceDeviceMemoryReportCreateInfoEXT( VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags_ = {}, + VULKAN_HPP_NAMESPACE::PFN_DeviceMemoryReportCallbackEXT pfnUserCallback_ = {}, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } , flags{ flags_ } , pfnUserCallback{ pfnUserCallback_ } @@ -27868,6 +28166,29 @@ namespace VULKAN_HPP_NAMESPACE { } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) + + DeviceDeviceMemoryReportCreateInfoEXT( VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags_, + PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback_, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : DeviceDeviceMemoryReportCreateInfoEXT( flags_, + reinterpret_cast( pfnUserCallback_ ), + pUserData_, + pNext_ ) + { + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif + DeviceDeviceMemoryReportCreateInfoEXT & operator=( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ @@ -27891,7 +28212,7 @@ namespace VULKAN_HPP_NAMESPACE } VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT & - setPfnUserCallback( PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT + setPfnUserCallback( VULKAN_HPP_NAMESPACE::PFN_DeviceMemoryReportCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT { pfnUserCallback = pfnUserCallback_; return *this; @@ -27902,6 +28223,23 @@ namespace VULKAN_HPP_NAMESPACE pUserData = pUserData_; return *this; } + +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + + DeviceDeviceMemoryReportCreateInfoEXT & setPfnUserCallback( PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnUserCallback( reinterpret_cast( pfnUserCallback_ ) ); + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif #endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ operator VkDeviceDeviceMemoryReportCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT @@ -27921,7 +28259,7 @@ namespace VULKAN_HPP_NAMESPACE std::tuple # endif reflect() const VULKAN_HPP_NOEXCEPT @@ -27946,11 +28284,11 @@ namespace VULKAN_HPP_NAMESPACE } public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceDeviceMemoryReportCreateInfoEXT; - const void * pNext = {}; - VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags = {}; - PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback = {}; - void * pUserData = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceDeviceMemoryReportCreateInfoEXT; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags = {}; + VULKAN_HPP_NAMESPACE::PFN_DeviceMemoryReportCallbackEXT pfnUserCallback = {}; + void * pUserData = {}; }; template <> @@ -30634,117 +30972,6 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceMemoryOverallocationCreateInfoAMD; }; - struct DeviceMemoryReportCallbackDataEXT - { - using NativeType = VkDeviceMemoryReportCallbackDataEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryReportCallbackDataEXT; - -#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceMemoryReportCallbackDataEXT( - VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags_ = {}, - VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT type_ = VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT::eAllocate, - uint64_t memoryObjectId_ = {}, - VULKAN_HPP_NAMESPACE::DeviceSize size_ = {}, - VULKAN_HPP_NAMESPACE::ObjectType objectType_ = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown, - uint64_t objectHandle_ = {}, - uint32_t heapIndex_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , type{ type_ } - , memoryObjectId{ memoryObjectId_ } - , size{ size_ } - , objectType{ objectType_ } - , objectHandle{ objectHandle_ } - , heapIndex{ heapIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceMemoryReportCallbackDataEXT( DeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceMemoryReportCallbackDataEXT( VkDeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceMemoryReportCallbackDataEXT( *reinterpret_cast( &rhs ) ) - { - } - - DeviceMemoryReportCallbackDataEXT & operator=( DeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ - - DeviceMemoryReportCallbackDataEXT & operator=( VkDeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDeviceMemoryReportCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceMemoryReportCallbackDataEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) -# if 14 <= VULKAN_HPP_CPP_VERSION - auto -# else - std::tuple -# endif - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, type, memoryObjectId, size, objectType, objectHandle, heapIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceMemoryReportCallbackDataEXT const & ) const = default; -#else - bool operator==( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( type == rhs.type ) && ( memoryObjectId == rhs.memoryObjectId ) && - ( size == rhs.size ) && ( objectType == rhs.objectType ) && ( objectHandle == rhs.objectHandle ) && ( heapIndex == rhs.heapIndex ); -# endif - } - - bool operator!=( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceMemoryReportCallbackDataEXT; - void * pNext = {}; - VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags = {}; - VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT type = VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT::eAllocate; - uint64_t memoryObjectId = {}; - VULKAN_HPP_NAMESPACE::DeviceSize size = {}; - VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown; - uint64_t objectHandle = {}; - uint32_t heapIndex = {}; - }; - - template <> - struct CppType - { - using Type = DeviceMemoryReportCallbackDataEXT; - }; - #if defined( VK_ENABLE_BETA_EXTENSIONS ) union DeviceOrHostAddressConstAMDX { @@ -31301,6 +31528,8 @@ namespace VULKAN_HPP_NAMESPACE using Type = DeviceQueueShaderCoreControlCreateInfoARM; }; + typedef PFN_vkVoidFunction( VKAPI_PTR * PFN_GetInstanceProcAddrLUNARG )( VULKAN_HPP_NAMESPACE::Instance instance, const char * pName ); + struct DirectDriverLoadingInfoLUNARG { using NativeType = VkDirectDriverLoadingInfoLUNARG; @@ -31310,7 +31539,7 @@ namespace VULKAN_HPP_NAMESPACE #if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) VULKAN_HPP_CONSTEXPR DirectDriverLoadingInfoLUNARG( VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG flags_ = {}, - PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ = {}, + VULKAN_HPP_NAMESPACE::PFN_GetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } , flags{ flags_ } @@ -31348,7 +31577,7 @@ namespace VULKAN_HPP_NAMESPACE } VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG & - setPfnGetInstanceProcAddr( PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ ) VULKAN_HPP_NOEXCEPT + setPfnGetInstanceProcAddr( VULKAN_HPP_NAMESPACE::PFN_GetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ ) VULKAN_HPP_NOEXCEPT { pfnGetInstanceProcAddr = pfnGetInstanceProcAddr_; return *this; @@ -31372,7 +31601,7 @@ namespace VULKAN_HPP_NAMESPACE std::tuple + VULKAN_HPP_NAMESPACE::PFN_GetInstanceProcAddrLUNARG const &> # endif reflect() const VULKAN_HPP_NOEXCEPT { @@ -31398,7 +31627,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDirectDriverLoadingInfoLUNARG; void * pNext = {}; VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG flags = {}; - PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr = {}; + VULKAN_HPP_NAMESPACE::PFN_GetInstanceProcAddrLUNARG pfnGetInstanceProcAddr = {}; }; template <>