From e5921db4394de097371e541785cc71bbd716e296 Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Tue, 26 Apr 2022 10:39:07 +0200 Subject: [PATCH] Combine two types of commands into one generation function --- VulkanHppGenerator.cpp | 302 +++++++--------- VulkanHppGenerator.hpp | 22 +- vulkan/vulkan.hpp | 36 -- vulkan/vulkan_enums.hpp | 52 +-- vulkan/vulkan_funcs.hpp | 712 ++++++++++++++++++++++++++------------ vulkan/vulkan_handles.hpp | 63 ++-- vulkan/vulkan_structs.hpp | 18 +- 7 files changed, 702 insertions(+), 503 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index f346285..ecd82e4 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -2267,7 +2267,8 @@ std::string VulkanHppGenerator::generateAllocatorTemplates( std::vector std::vector const & returnDataTypes, std::map const & vectorParams, bool definition, - bool singular ) const + bool singular, + bool unique ) const { assert( returnParams.size() == returnDataTypes.size() ); std::string allocatorTemplates; @@ -2280,7 +2281,7 @@ std::string VulkanHppGenerator::generateAllocatorTemplates( std::vector allocatorTemplates += "typename " + startUpperCase( stripPrefix( returnDataTypes[i], "VULKAN_HPP_NAMESPACE::" ) ) + "Allocator"; if ( !definition ) { - allocatorTemplates += " = std::allocator<" + returnDataTypes[i] + ">"; + allocatorTemplates += " = std::allocator<" + ( unique ? ( "UniqueHandle<" + returnDataTypes[i] + ", Dispatch>" ) : returnDataTypes[i] ) + ">"; } allocatorTemplates += ", "; } @@ -3230,13 +3231,19 @@ std::string VulkanHppGenerator::generateCommandEnhanced( std::string const & std::string argumentTemplates = generateArgumentTemplates( commandData.params, templatedParams, false ); std::string chainTemplates = chained ? "typename X, typename Y, typename... Z, " : ""; - std::string allocatorTemplates = generateAllocatorTemplates( returnParams, dataTypes, vectorParams, definition, singular ); - std::string typenameCheck = generateTypenameCheck( commandData, returnParams, vectorParams, definition, false, withAllocator ); - std::string nodiscard = generateNoDiscard( !returnParams.empty(), 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); - std::string returnType = generateReturnType( commandData, returnParams, vectorParams, singular, unique, chained, dataType ); - std::string className = initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : ""; - std::string classSeparator = commandData.handle.empty() ? "" : "::"; - std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags, singular, unique ); + std::string allocatorTemplates = generateAllocatorTemplates( returnParams, dataTypes, vectorParams, definition, singular, unique ); + std::string uniqueHandleAllocatorTemplates; + if ( unique && !allocatorTemplates.empty() ) + { + uniqueHandleAllocatorTemplates = ", " + stripPostfix( allocatorTemplates, ", " ); + allocatorTemplates.clear(); + } + std::string typenameCheck = generateTypenameCheck( commandData, returnParams, vectorParams, definition, singular, withAllocator, unique ); + std::string nodiscard = generateNoDiscard( !returnParams.empty(), 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); + std::string returnType = generateReturnType( commandData, returnParams, vectorParams, singular, unique, chained, dataType ); + std::string className = initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : ""; + std::string classSeparator = commandData.handle.empty() ? "" : "::"; + std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags, singular, unique ); std::string argumentList = generateArgumentListEnhanced( commandData.params, skippedParams, singularParams, templatedParams, definition, withAllocator, chained, true ); std::string constString = commandData.handle.empty() ? "" : " const"; @@ -3256,7 +3263,9 @@ std::string VulkanHppGenerator::generateCommandEnhanced( std::string const & vectorSizeCheck.first ? generateVectorSizeCheck( name, commandData, initialSkipCount, vectorSizeCheck.second, skippedParams, false ) : ""; std::string returnVariable = generateReturnVariable( commandData, returnParams, vectorParams, chained, singular ); std::string dataDeclarations = generateDataDeclarations( - commandData, returnParams, vectorParams, templatedParams, singular, withAllocator, chained, dataTypes, returnType, returnVariable ); + commandData, returnParams, vectorParams, templatedParams, singular, withAllocator, chained, unique, dataTypes, returnType, returnVariable ); + std::string dataPreparation = + generateDataPreparation( commandData, initialSkipCount, returnParams, vectorParams, templatedParams, singular, withAllocator, unique ); std::string dataSizeChecks = generateDataSizeChecks( commandData, returnParams, dataTypes, vectorParams, templatedParams, singular ); std::string callSequence = generateCallSequence( name, commandData, returnParams, vectorParams, initialSkipCount, singularParams, templatedParams ); std::string resultCheck = generateResultCheck( commandData, className, classSeparator, commandName ); @@ -3264,7 +3273,7 @@ std::string VulkanHppGenerator::generateCommandEnhanced( std::string const & name, commandData, returnVariable, returnType, dataType, initialSkipCount, returnParams.empty() ? INVALID_INDEX : returnParams[0], unique ); std::string const functionTemplate = - R"( template <${argumentTemplates}${chainTemplates}${allocatorTemplates}typename Dispatch${typenameCheck}> + R"( template <${argumentTemplates}${chainTemplates}${allocatorTemplates}typename Dispatch${uniqueHandleAllocatorTemplates}${typenameCheck}> ${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}${classSeparator}${commandName}( ${argumentList} )${const}${noexcept} { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -3273,6 +3282,7 @@ ${vectorSizeCheck} ${dataDeclarations} ${callSequence} ${resultCheck} + ${dataPreparation} ${returnStatement} })"; @@ -3287,6 +3297,7 @@ ${vectorSizeCheck} { "commandName", commandName }, { "const", constString }, { "dataDeclarations", dataDeclarations }, + { "dataPreparation", dataPreparation }, { "dataSizeChecks", dataSizeChecks }, { "nodiscard", nodiscard }, { "noexcept", noexceptString }, @@ -3294,12 +3305,13 @@ ${vectorSizeCheck} { "returnStatement", returnStatement }, { "returnType", returnType }, { "typenameCheck", typenameCheck }, + { "uniqueHandleAllocatorTemplates", uniqueHandleAllocatorTemplates }, { "vectorSizeCheck", vectorSizeCheckString } } ); } else { std::string const functionTemplate = - R"( template <${argumentTemplates}${chainTemplates}${allocatorTemplates}typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${typenameCheck}> + R"( template <${argumentTemplates}${chainTemplates}${allocatorTemplates}typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${uniqueHandleAllocatorTemplates}${typenameCheck}> ${nodiscard}${returnType} ${commandName}( ${argumentList} )${const}${noexcept};)"; return replaceWithMap( functionTemplate, @@ -3312,7 +3324,8 @@ ${vectorSizeCheck} { "nodiscard", nodiscard }, { "noexcept", noexceptString }, { "returnType", returnType }, - { "typenameCheck", typenameCheck } } ); + { "typenameCheck", typenameCheck }, + { "uniqueHandleAllocatorTemplates", uniqueHandleAllocatorTemplates } } ); } } @@ -3666,115 +3679,6 @@ std::string VulkanHppGenerator::generateCommandResultEnumerateTwoVectors( std::s } } -std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesUnique( std::string const & name, - CommandData const & commandData, - size_t initialSkipCount, - bool definition, - std::map const & vectorParams, - size_t returnParam, - bool withAllocator ) const -{ - assert( commandData.returnType == "VkResult" ); - - std::set skippedParams = determineSkippedParams( commandData.params, initialSkipCount, vectorParams, { returnParam }, false ); - std::string argumentList = generateArgumentListEnhanced( commandData.params, skippedParams, {}, {}, definition, withAllocator, false, true ); - std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags, false, true ); - std::string nodiscard = generateNoDiscard( true, 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); - std::string handleType = stripPrefix( commandData.params[returnParam].type.type, "Vk" ); - std::string returnType = - generateReturnType( commandData, { returnParam }, vectorParams, false, true, false, "std::vector<" + handleType + ", " + handleType + "Allocator>" ); - - if ( definition ) - { - std::string const functionTemplate = - R"( template - ${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}${classSeparator}${commandName}( ${argumentList} ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, ${handleType}Allocator> ${uniqueVectorName}${vectorAllocator}; - std::vector<${handleType}> ${vectorName}( ${vectorSize} ); - Result result = static_cast( d.${vkCommand}( ${callArguments} ) ); - if ( ${successCheck} ) - { - ${uniqueVectorName}.reserve( ${vectorSize} ); - ${deleterDefinition}; - for ( size_t i=0; i < ${vectorSize}; i++ ) - { - ${uniqueVectorName}.push_back( UniqueHandle<${handleType}, Dispatch>( ${vectorName}[i], deleter ) ); - } - } - return createResultValue( result, std::move( ${uniqueVectorName} ), VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} ); - })"; - - std::string className = initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : ""; - - std::string deleterDefinition; - std::vector lenParts = tokenize( commandData.params[returnParam].len, "->" ); - switch ( lenParts.size() ) - { - case 1: deleterDefinition = "ObjectDestroy<" + className + ", Dispatch> deleter( *this, allocator, d )"; break; - case 2: - { - auto vpiIt = vectorParams.find( returnParam ); - assert( vpiIt != vectorParams.end() ); - std::string poolType, poolName; - std::tie( poolType, poolName ) = getPoolTypeAndName( commandData.params[vpiIt->second].type.type ); - assert( !poolType.empty() ); - poolType = stripPrefix( poolType, "Vk" ); - poolName = startLowerCase( stripPrefix( lenParts[0], "p" ) ) + "." + poolName; - deleterDefinition = "PoolFree<" + className + ", " + poolType + ", Dispatch> deleter( *this, " + poolName + ", d )"; - } - break; - } - - std::string typenameCheck = - withAllocator - ? ( ", typename B, typename std::enable_if>::value, int>::type " ) - : ""; - std::string vectorName = startLowerCase( stripPrefix( commandData.params[returnParam].name, "p" ) ); - std::string vectorSize = getVectorSize( - commandData.params, vectorParams, returnParam, commandData.params[returnParam].type.type, determineVoidPointerParams( commandData.params ) ); - - return replaceWithMap( functionTemplate, - { { "argumentList", argumentList }, - { "callArguments", generateCallArgumentsEnhanced( commandData, initialSkipCount, false, {}, {}, false ) }, - { "className", className }, - { "classSeparator", commandData.handle.empty() ? "" : "::" }, - { "commandName", commandName }, - { "deleterDefinition", deleterDefinition }, - { "handleType", handleType }, - { "nodiscard", nodiscard }, - { "returnType", returnType }, - { "successCheck", generateSuccessCheck( commandData.successCodes ) }, - { "successCodeList", generateSuccessCodeList( commandData.successCodes ) }, - { "typenameCheck", typenameCheck }, - { "uniqueVectorName", "unique" + stripPrefix( commandData.params[returnParam].name, "p" ) }, - { "vectorAllocator", withAllocator ? ( "( " + startLowerCase( handleType ) + "Allocator )" ) : "" }, - { "vectorName", vectorName }, - { "vectorSize", vectorSize }, - { "vkCommand", name } } ); - } - else - { - std::string const functionTemplate = - R"( template >${typenameCheck}> - ${nodiscard}${returnType} ${commandName}( ${argumentList} ) const;)"; - - std::string typenameCheck = withAllocator - ? ( ", typename B = " + handleType + "Allocator, typename std::enable_if>::value, int>::type = 0" ) - : ""; - - return replaceWithMap( functionTemplate, - { { "argumentList", argumentList }, - { "commandName", commandName }, - { "handleType", handleType }, - { "nodiscard", nodiscard }, - { "returnType", returnType }, - { "typenameCheck", typenameCheck } } ); - } -} - std::string VulkanHppGenerator::generateCommandResultMultiSuccessNoErrors( std::string const & name, CommandData const & commandData, size_t initialSkipCount, @@ -3895,8 +3799,8 @@ std::string VulkanHppGenerator::generateCommandResultMultiSuccessWithErrors1Retu generateCommandEnhanced( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false, false, false, false ), generateCommandEnhanced( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false, true, false, false ), generateCommandEnhanced( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true, false, false, false ), - generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ), - generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ), + generateCommandEnhanced( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false, false, false, true ), + generateCommandEnhanced( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false, true, false, true ), generateCommandEnhanced( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true, false, false, true ) ); } } @@ -4149,8 +4053,8 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandEnhanced( name, commandData, initialSkipCount, definition, { vectorParamIndex }, { returnParam }, false, false, false, false ), generateCommandEnhanced( name, commandData, initialSkipCount, definition, { vectorParamIndex }, { returnParam }, false, true, false, false ), - generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, { vectorParamIndex }, returnParam, false ), - generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, { vectorParamIndex }, returnParam, true ) ); + generateCommandEnhanced( name, commandData, initialSkipCount, definition, { vectorParamIndex }, { returnParam }, false, false, false, true ), + generateCommandEnhanced( name, commandData, initialSkipCount, definition, { vectorParamIndex }, { returnParam }, false, true, false, true ) ); } } return ""; @@ -4177,8 +4081,8 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret generateCommandEnhanced( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false, false, false, false ), generateCommandEnhanced( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false, true, false, false ), generateCommandEnhanced( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true, false, false, false ), - generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ), - generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ), + generateCommandEnhanced( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false, false, false, true ), + generateCommandEnhanced( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false, true, false, true ), generateCommandEnhanced( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true, false, false, true ) ); } } @@ -4900,6 +4804,7 @@ std::string VulkanHppGenerator::generateDataDeclarations( CommandData const & bool singular, bool withAllocator, bool chained, + bool unique, std::vector const & dataTypes, std::string const & returnType, std::string const & returnVariable ) const @@ -4935,12 +4840,12 @@ std::string VulkanHppGenerator::generateDataDeclarations( CommandData const & std::string dataTypeAllocator = startUpperCase( stripPrefix( dataTypes[0], "VULKAN_HPP_NAMESPACE::" ) ) + "Allocator"; std::string vectorSize = getVectorSize( commandData.params, vectorParams, returnParams[0], dataTypes[0], templatedParams ); - std::string const dataDeclarationsTemplate = R"(std::vector<${dataType}, ${dataTypeAllocator}> ${dataVariable}( ${vectorSize}${vectorAllocator} );)"; + std::string const dataDeclarationsTemplate = R"(std::vector<${dataType}${dataTypeAllocator}> ${dataVariable}( ${vectorSize}${vectorAllocator} );)"; dataDeclarations = replaceWithMap( dataDeclarationsTemplate, { { "dataType", dataTypes[0] }, - { "dataTypeAllocator", dataTypeAllocator }, + { "dataTypeAllocator", unique ? "" : ( ", " + dataTypeAllocator ) }, { "dataVariable", returnVariable }, - { "vectorAllocator", withAllocator ? ( ", " + startLowerCase( dataTypeAllocator ) ) : "" }, + { "vectorAllocator", ( withAllocator && !unique ) ? ( ", " + startLowerCase( dataTypeAllocator ) ) : "" }, { "vectorSize", vectorSize } } ); } } @@ -5025,6 +4930,65 @@ std::string VulkanHppGenerator::generateDataDeclarations( CommandData const & return dataDeclarations; } +std::string VulkanHppGenerator::generateDataPreparation( CommandData const & commandData, + size_t initialSkipCount, + std::vector const & returnParams, + std::map const & vectorParams, + std::set const & templatedParams, + bool singular, + bool withAllocator, + bool unique ) const +{ + if ( unique && !singular && ( returnParams.size() == 1 ) && ( vectorParams.find( returnParams[0] ) != vectorParams.end() ) ) + { + std::string className = initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : ""; + std::string deleterDefinition; + std::vector lenParts = tokenize( commandData.params[returnParams[0]].len, "->" ); + switch ( lenParts.size() ) + { + case 1: deleterDefinition = "ObjectDestroy<" + className + ", Dispatch> deleter( *this, allocator, d )"; break; + case 2: + { + auto vpiIt = vectorParams.find( returnParams[0] ); + assert( vpiIt != vectorParams.end() ); + std::string poolType, poolName; + std::tie( poolType, poolName ) = getPoolTypeAndName( commandData.params[vpiIt->second].type.type ); + assert( !poolType.empty() ); + poolType = stripPrefix( poolType, "Vk" ); + poolName = startLowerCase( stripPrefix( lenParts[0], "p" ) ) + "." + poolName; + deleterDefinition = "PoolFree<" + className + ", " + poolType + ", Dispatch> deleter( *this, " + poolName + ", d )"; + } + break; + } + + std::string handleType = stripPrefix( commandData.params[returnParams[0]].type.type, "Vk" ); + std::string uniqueVectorName = "unique" + stripPrefix( commandData.params[returnParams[0]].name, "p" ); + std::string vectorAllocator = withAllocator ? ( "( " + startLowerCase( handleType ) + "Allocator )" ) : ""; + std::string vectorName = startLowerCase( stripPrefix( commandData.params[returnParams[0]].name, "p" ) ); + std::string elementName = stripPluralS( vectorName ); + std::string vectorSize = getVectorSize( commandData.params, vectorParams, returnParams[0], commandData.params[returnParams[0]].type.type, templatedParams ); + + std::string const dataPreparationTemplate = + R"(std::vector, ${handleType}Allocator> ${uniqueVectorName}${vectorAllocator}; + ${uniqueVectorName}.reserve( ${vectorSize} ); + ${deleterDefinition}; + for ( auto const & ${elementName} : ${vectorName} ) + { + ${uniqueVectorName}.push_back( UniqueHandle<${handleType}, Dispatch>( ${elementName}, deleter ) ); + })"; + + return replaceWithMap( dataPreparationTemplate, + { { "elementName", elementName }, + { "deleterDefinition", deleterDefinition }, + { "handleType", handleType }, + { "uniqueVectorName", uniqueVectorName }, + { "vectorAllocator", vectorAllocator }, + { "vectorName", vectorName }, + { "vectorSize", vectorSize } } ); + } + return ""; +} + std::string VulkanHppGenerator::generateDataSizeChecks( CommandData const & commandData, std::vector const & returnParams, std::vector const & returnParamTypes, @@ -10009,8 +9973,17 @@ std::string VulkanHppGenerator::generateReturnStatement( std::string const & com else if ( unique ) { assert( returnParam != INVALID_INDEX ); - returnStatement = "return createResultValueType( static_cast( result ), UniqueHandle<" + dataType + ", Dispatch>( " + - returnVariable + ", " + generateObjectDeleter( commandName, commandData, initialSkipCount, returnParam ) + " ) );"; + returnStatement = "return createResultValueType( static_cast( result ), "; + if ( beginsWith( dataType, "std::" ) ) + { + returnStatement += "std::move( unique" + startUpperCase( returnVariable ) + " )"; + } + else + { + returnStatement += "UniqueHandle<" + dataType + ", Dispatch>( " + returnVariable + ", " + + generateObjectDeleter( commandName, commandData, initialSkipCount, returnParam ) + " )"; + } + returnStatement += " );"; } else { @@ -10029,8 +10002,17 @@ std::string VulkanHppGenerator::generateReturnStatement( std::string const & com { assert( returnParam != INVALID_INDEX ); assert( beginsWith( returnType, "ResultValue<" ) && endsWith( returnType, ">" ) ); - returnStatement = "return " + returnType + "( static_cast( result ), UniqueHandle<" + dataType + ", Dispatch>( " + - returnVariable + ", " + generateObjectDeleter( commandName, commandData, initialSkipCount, returnParam ) + " ) );"; + returnStatement = "return " + returnType + "( static_cast( result ), "; + if ( beginsWith( dataType, "std::" ) ) + { + returnStatement += "std::move( unique" + startUpperCase( returnVariable ) + " )"; + } + else + { + returnStatement += "UniqueHandle<" + dataType + ", Dispatch>( " + returnVariable + ", " + + generateObjectDeleter( commandName, commandData, initialSkipCount, returnParam ) + " )"; + } + returnStatement += " );"; } else { @@ -11211,7 +11193,8 @@ std::string VulkanHppGenerator::generateTypenameCheck( CommandData const & std::map const & vectorParams, bool definition, bool singular, - bool withAllocator ) const + bool withAllocator, + bool unique ) const { std::string typenameCheck; if ( !singular && withAllocator ) @@ -11220,15 +11203,20 @@ std::string VulkanHppGenerator::generateTypenameCheck( CommandData const & { if ( vectorParams.find( returnParam ) != vectorParams.end() ) { - std::string elementType = stripPrefix( commandData.params[returnParam].type.type, "Vk" ); + std::string elementType = stripPrefix( commandData.params[returnParam].type.type, "Vk" ); + std::string extendedElementType = elementType; + if ( unique ) + { + extendedElementType = "UniqueHandle<" + elementType + ", Dispatch>"; + } if ( definition ) { - typenameCheck += ", typename B, typename std::enable_if::value, int>::type "; + typenameCheck += ", typename B, typename std::enable_if::value, int>::type "; } else { typenameCheck += ", typename B = " + startUpperCase( elementType ) + "Allocator, typename std::enable_if::value, int>::type = 0"; + extendedElementType + ">::value, int>::type = 0"; } } } @@ -16696,42 +16684,6 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h #endif } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template >> - VULKAN_HPP_INLINE typename ResultValueType, Allocator>>::type - createResultValue( Result result, std::vector, Allocator> && data, char const * message ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - ignore( message ); - VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess ); - return ResultValue, Allocator>>( result, std::move( data ) ); -# else - if ( result != Result::eSuccess ) - { - throwResultException( result, message ); - } - return std::move( data ); -# endif - } - - template >> - VULKAN_HPP_INLINE ResultValue, Allocator>> - createResultValue( Result result, std::vector, Allocator> && data, char const * message, std::initializer_list successCodes ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - ignore( message ); - ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty - VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); -# else - if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) - { - throwResultException( result, message ); - } -# endif - return ResultValue, Allocator>>( result, std::move( data ) ); - } -#endif - VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result ) { #ifdef VULKAN_HPP_NO_EXCEPTIONS diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index 7d4667d..b777031 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -422,7 +422,8 @@ private: std::vector const & returnDataTypes, std::map const & vectorParams, bool definition, - bool singular ) const; + bool singular, + bool unique ) const; std::string generateArgumentListEnhanced( std::vector const & params, std::set const & skippedParams, std::set const & singularParams, @@ -505,13 +506,6 @@ private: std::map const & vectorParamIndices, std::vector const & returnParamIndices, bool withAllocators ) const; - std::string generateCommandResultGetVectorOfHandlesUnique( std::string const & name, - CommandData const & commandData, - size_t initialSkipCount, - bool definition, - std::map const & vectorParamIndices, - size_t returnParam, - bool withAllocator ) const; std::string generateCommandResultMultiSuccessNoErrors( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const; std::string generateCommandResultMultiSuccessNoErrors0Return( std::string const & name, @@ -630,9 +624,18 @@ private: bool singular, bool withAllocator, bool chained, + bool unique, std::vector const & dataTypes, std::string const & returnType, std::string const & returnVariable ) const; + std::string generateDataPreparation( CommandData const & commandData, + size_t initialSkipCount, + std::vector const & returnParams, + std::map const & vectorParams, + std::set const & templatedParams, + bool singular, + bool withAllocator, + bool unique ) const; std::string generateDataSizeChecks( CommandData const & commandData, std::vector const & returnParams, std::vector const & returnParamTypes, @@ -987,7 +990,8 @@ private: std::map const & vectorParams, bool definition, bool singular, - bool withAllocator ) const; + bool withAllocator, + bool unique ) const; std::string generateUnion( std::pair const & structure ) const; std::string generateUniqueTypes( std::string const & parentType, std::set const & childrenTypes ) const; std::string generateVectorSizeCheck( std::string const & name, diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 7f2097c..1dd563a 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -6017,42 +6017,6 @@ namespace VULKAN_HPP_NAMESPACE #endif } -#ifndef VULKAN_HPP_NO_SMART_HANDLE - template >> - VULKAN_HPP_INLINE typename ResultValueType, Allocator>>::type - createResultValue( Result result, std::vector, Allocator> && data, char const * message ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - ignore( message ); - VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess ); - return ResultValue, Allocator>>( result, std::move( data ) ); -# else - if ( result != Result::eSuccess ) - { - throwResultException( result, message ); - } - return std::move( data ); -# endif - } - - template >> - VULKAN_HPP_INLINE ResultValue, Allocator>> - createResultValue( Result result, std::vector, Allocator> && data, char const * message, std::initializer_list successCodes ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - ignore( message ); - ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty - VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); -# else - if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) - { - throwResultException( result, message ); - } -# endif - return ResultValue, Allocator>>( result, std::move( data ) ); - } -#endif - VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result ) { #ifdef VULKAN_HPP_NO_EXCEPTIONS diff --git a/vulkan/vulkan_enums.hpp b/vulkan/vulkan_enums.hpp index 3b9e338..c53834e 100644 --- a/vulkan/vulkan_enums.hpp +++ b/vulkan/vulkan_enums.hpp @@ -8353,12 +8353,12 @@ namespace VULKAN_HPP_NAMESPACE VkFlags( FormatFeatureFlagBits::eDisjoint ) | VkFlags( FormatFeatureFlagBits::eCositedChromaSamples ) | VkFlags( FormatFeatureFlagBits::eSampledImageFilterMinmax ) | VkFlags( FormatFeatureFlagBits::eSampledImageFilterCubicIMG ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( FormatFeatureFlagBits::eVideoDecodeOutputKHR ) | VkFlags( FormatFeatureFlagBits::eVideoDecodeDpbKHR ) + | VkFlags( FormatFeatureFlagBits::eVideoDecodeOutputKHR ) | VkFlags( FormatFeatureFlagBits::eVideoDecodeDpbKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags( FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR ) | VkFlags( FormatFeatureFlagBits::eFragmentDensityMapEXT ) | + | VkFlags( FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR ) | VkFlags( FormatFeatureFlagBits::eFragmentDensityMapEXT ) | VkFlags( FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( FormatFeatureFlagBits::eVideoEncodeInputKHR ) | VkFlags( FormatFeatureFlagBits::eVideoEncodeDpbKHR ) + | VkFlags( FormatFeatureFlagBits::eVideoEncodeInputKHR ) | VkFlags( FormatFeatureFlagBits::eVideoEncodeDpbKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ }; }; @@ -8553,15 +8553,15 @@ namespace VULKAN_HPP_NAMESPACE VkFlags( ImageUsageFlagBits::eDepthStencilAttachment ) | VkFlags( ImageUsageFlagBits::eTransientAttachment ) | VkFlags( ImageUsageFlagBits::eInputAttachment ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( ImageUsageFlagBits::eVideoDecodeDstKHR ) | VkFlags( ImageUsageFlagBits::eVideoDecodeSrcKHR ) | + | VkFlags( ImageUsageFlagBits::eVideoDecodeDstKHR ) | VkFlags( ImageUsageFlagBits::eVideoDecodeSrcKHR ) | VkFlags( ImageUsageFlagBits::eVideoDecodeDpbKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags( ImageUsageFlagBits::eFragmentDensityMapEXT ) | VkFlags( ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR ) + | VkFlags( ImageUsageFlagBits::eFragmentDensityMapEXT ) | VkFlags( ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( ImageUsageFlagBits::eVideoEncodeDstKHR ) | VkFlags( ImageUsageFlagBits::eVideoEncodeSrcKHR ) | + | VkFlags( ImageUsageFlagBits::eVideoEncodeDstKHR ) | VkFlags( ImageUsageFlagBits::eVideoEncodeSrcKHR ) | VkFlags( ImageUsageFlagBits::eVideoEncodeDpbKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags( ImageUsageFlagBits::eInvocationMaskHUAWEI ) + | VkFlags( ImageUsageFlagBits::eInvocationMaskHUAWEI ) }; }; @@ -8794,7 +8794,7 @@ namespace VULKAN_HPP_NAMESPACE allFlags = VkFlags( QueueFlagBits::eGraphics ) | VkFlags( QueueFlagBits::eCompute ) | VkFlags( QueueFlagBits::eTransfer ) | VkFlags( QueueFlagBits::eSparseBinding ) | VkFlags( QueueFlagBits::eProtected ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( QueueFlagBits::eVideoDecodeKHR ) | VkFlags( QueueFlagBits::eVideoEncodeKHR ) + | VkFlags( QueueFlagBits::eVideoDecodeKHR ) | VkFlags( QueueFlagBits::eVideoEncodeKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ }; }; @@ -9404,7 +9404,7 @@ namespace VULKAN_HPP_NAMESPACE allFlags = VkFlags( QueryResultFlagBits::e64 ) | VkFlags( QueryResultFlagBits::eWait ) | VkFlags( QueryResultFlagBits::eWithAvailability ) | VkFlags( QueryResultFlagBits::ePartial ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( QueryResultFlagBits::eWithStatusKHR ) + | VkFlags( QueryResultFlagBits::eWithStatusKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ }; }; @@ -9517,13 +9517,13 @@ namespace VULKAN_HPP_NAMESPACE VkFlags( BufferUsageFlagBits::eIndexBuffer ) | VkFlags( BufferUsageFlagBits::eVertexBuffer ) | VkFlags( BufferUsageFlagBits::eIndirectBuffer ) | VkFlags( BufferUsageFlagBits::eShaderDeviceAddress ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( BufferUsageFlagBits::eVideoDecodeSrcKHR ) | VkFlags( BufferUsageFlagBits::eVideoDecodeDstKHR ) + | VkFlags( BufferUsageFlagBits::eVideoDecodeSrcKHR ) | VkFlags( BufferUsageFlagBits::eVideoDecodeDstKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags( BufferUsageFlagBits::eTransformFeedbackBufferEXT ) | VkFlags( BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT ) | + | VkFlags( BufferUsageFlagBits::eTransformFeedbackBufferEXT ) | VkFlags( BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT ) | VkFlags( BufferUsageFlagBits::eConditionalRenderingEXT ) | VkFlags( BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR ) | VkFlags( BufferUsageFlagBits::eAccelerationStructureStorageKHR ) | VkFlags( BufferUsageFlagBits::eShaderBindingTableKHR ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( BufferUsageFlagBits::eVideoEncodeDstKHR ) | VkFlags( BufferUsageFlagBits::eVideoEncodeSrcKHR ) + | VkFlags( BufferUsageFlagBits::eVideoEncodeDstKHR ) | VkFlags( BufferUsageFlagBits::eVideoEncodeSrcKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ }; }; @@ -11194,13 +11194,13 @@ namespace VULKAN_HPP_NAMESPACE VkFlags( ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eD3D12Heap ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eD3D12Resource ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eDmaBufEXT ) #if defined( VK_USE_PLATFORM_ANDROID_KHR ) - | VkFlags( ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID ) + | VkFlags( ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID ) #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - | VkFlags( ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT ) + | VkFlags( ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT ) #if defined( VK_USE_PLATFORM_FUCHSIA ) - | VkFlags( ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA ) + | VkFlags( ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA ) #endif /*VK_USE_PLATFORM_FUCHSIA*/ - | VkFlags( ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV ) + | VkFlags( ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV ) }; }; @@ -11528,7 +11528,7 @@ namespace VULKAN_HPP_NAMESPACE VkFlags( ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt ) | VkFlags( ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence ) | VkFlags( ExternalSemaphoreHandleTypeFlagBits::eSyncFd ) #if defined( VK_USE_PLATFORM_FUCHSIA ) - | VkFlags( ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA ) + | VkFlags( ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA ) #endif /*VK_USE_PLATFORM_FUCHSIA*/ }; }; @@ -11926,9 +11926,9 @@ namespace VULKAN_HPP_NAMESPACE VkFlags64( PipelineStageFlagBits2::eClear ) | VkFlags64( PipelineStageFlagBits2::eIndexInput ) | VkFlags64( PipelineStageFlagBits2::eVertexAttributeInput ) | VkFlags64( PipelineStageFlagBits2::ePreRasterizationShaders ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags64( PipelineStageFlagBits2::eVideoDecodeKHR ) | VkFlags64( PipelineStageFlagBits2::eVideoEncodeKHR ) + | VkFlags64( PipelineStageFlagBits2::eVideoDecodeKHR ) | VkFlags64( PipelineStageFlagBits2::eVideoEncodeKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags64( PipelineStageFlagBits2::eTransformFeedbackEXT ) | VkFlags64( PipelineStageFlagBits2::eConditionalRenderingEXT ) | + | VkFlags64( PipelineStageFlagBits2::eTransformFeedbackEXT ) | VkFlags64( PipelineStageFlagBits2::eConditionalRenderingEXT ) | VkFlags64( PipelineStageFlagBits2::eCommandPreprocessNV ) | VkFlags64( PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR ) | VkFlags64( PipelineStageFlagBits2::eAccelerationStructureBuildKHR ) | VkFlags64( PipelineStageFlagBits2::eRayTracingShaderKHR ) | VkFlags64( PipelineStageFlagBits2::eFragmentDensityProcessEXT ) | VkFlags64( PipelineStageFlagBits2::eTaskShaderNV ) | @@ -12062,10 +12062,10 @@ namespace VULKAN_HPP_NAMESPACE VkFlags64( AccessFlagBits2::eShaderSampledRead ) | VkFlags64( AccessFlagBits2::eShaderStorageRead ) | VkFlags64( AccessFlagBits2::eShaderStorageWrite ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags64( AccessFlagBits2::eVideoDecodeReadKHR ) | VkFlags64( AccessFlagBits2::eVideoDecodeWriteKHR ) | + | VkFlags64( AccessFlagBits2::eVideoDecodeReadKHR ) | VkFlags64( AccessFlagBits2::eVideoDecodeWriteKHR ) | VkFlags64( AccessFlagBits2::eVideoEncodeReadKHR ) | VkFlags64( AccessFlagBits2::eVideoEncodeWriteKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags64( AccessFlagBits2::eTransformFeedbackWriteEXT ) | VkFlags64( AccessFlagBits2::eTransformFeedbackCounterReadEXT ) | + | VkFlags64( AccessFlagBits2::eTransformFeedbackWriteEXT ) | VkFlags64( AccessFlagBits2::eTransformFeedbackCounterReadEXT ) | VkFlags64( AccessFlagBits2::eTransformFeedbackCounterWriteEXT ) | VkFlags64( AccessFlagBits2::eConditionalRenderingReadEXT ) | VkFlags64( AccessFlagBits2::eCommandPreprocessReadNV ) | VkFlags64( AccessFlagBits2::eCommandPreprocessWriteNV ) | VkFlags64( AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR ) | VkFlags64( AccessFlagBits2::eAccelerationStructureReadKHR ) | @@ -12299,14 +12299,14 @@ namespace VULKAN_HPP_NAMESPACE VkFlags64( FormatFeatureFlagBits2::eStorageReadWithoutFormat ) | VkFlags64( FormatFeatureFlagBits2::eStorageWriteWithoutFormat ) | VkFlags64( FormatFeatureFlagBits2::eSampledImageDepthComparison ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags64( FormatFeatureFlagBits2::eVideoDecodeOutputKHR ) | VkFlags64( FormatFeatureFlagBits2::eVideoDecodeDpbKHR ) + | VkFlags64( FormatFeatureFlagBits2::eVideoDecodeOutputKHR ) | VkFlags64( FormatFeatureFlagBits2::eVideoDecodeDpbKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags64( FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR ) | VkFlags64( FormatFeatureFlagBits2::eFragmentDensityMapEXT ) | + | VkFlags64( FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR ) | VkFlags64( FormatFeatureFlagBits2::eFragmentDensityMapEXT ) | VkFlags64( FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags64( FormatFeatureFlagBits2::eVideoEncodeInputKHR ) | VkFlags64( FormatFeatureFlagBits2::eVideoEncodeDpbKHR ) + | VkFlags64( FormatFeatureFlagBits2::eVideoEncodeInputKHR ) | VkFlags64( FormatFeatureFlagBits2::eVideoEncodeDpbKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags64( FormatFeatureFlagBits2::eLinearColorAttachmentNV ) + | VkFlags64( FormatFeatureFlagBits2::eLinearColorAttachmentNV ) }; }; @@ -12830,7 +12830,7 @@ namespace VULKAN_HPP_NAMESPACE { allFlags = VkFlags( VideoCodecOperationFlagBitsKHR::eInvalid ) # if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( VideoCodecOperationFlagBitsKHR::eEncodeH264EXT ) | VkFlags( VideoCodecOperationFlagBitsKHR::eEncodeH265EXT ) | + | VkFlags( VideoCodecOperationFlagBitsKHR::eEncodeH264EXT ) | VkFlags( VideoCodecOperationFlagBitsKHR::eEncodeH265EXT ) | VkFlags( VideoCodecOperationFlagBitsKHR::eDecodeH264EXT ) | VkFlags( VideoCodecOperationFlagBitsKHR::eDecodeH265EXT ) # endif /*VK_ENABLE_BETA_EXTENSIONS*/ }; diff --git a/vulkan/vulkan_funcs.hpp b/vulkan/vulkan_funcs.hpp index 66d8daa..107b11c 100644 --- a/vulkan/vulkan_funcs.hpp +++ b/vulkan/vulkan_funcs.hpp @@ -41,6 +41,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &instance ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::createInstance" ); + return createResultValueType( static_cast( result ), instance ); } @@ -57,6 +58,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &instance ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::createInstanceUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( instance, ObjectDestroy( allocator, d ) ) ); } @@ -237,6 +239,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( flags ), reinterpret_cast( &imageFormatProperties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" ); + return createResultValueType( static_cast( result ), imageFormatProperties ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -399,6 +402,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &device ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDevice" ); + return createResultValueType( static_cast( result ), device ); } @@ -418,6 +422,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &device ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDeviceUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( device, ObjectDestroy( allocator, d ) ) ); } @@ -779,6 +784,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkQueueSubmit( m_queue, submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -798,6 +804,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkQueueWaitIdle( m_queue ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -817,6 +824,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkDeviceWaitIdle( m_device ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -850,6 +858,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &memory ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemory" ); + return createResultValueType( static_cast( result ), memory ); } @@ -869,6 +878,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &memory ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemoryUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( memory, ObjectFree( *this, allocator, d ) ) ); } @@ -956,6 +966,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( flags ), &pData ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory" ); + return createResultValueType( static_cast( result ), pData ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -985,6 +996,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkFlushMappedMemoryRanges( m_device, memoryRanges.size(), reinterpret_cast( memoryRanges.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1008,6 +1020,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size(), reinterpret_cast( memoryRanges.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1056,6 +1069,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkBindBufferMemory( m_device, static_cast( buffer ), static_cast( memory ), static_cast( memoryOffset ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1081,6 +1095,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkBindImageMemory( m_device, static_cast( image ), static_cast( memory ), static_cast( memoryOffset ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1308,6 +1323,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkQueueBindSparse( m_queue, bindInfo.size(), reinterpret_cast( bindInfo.data() ), static_cast( fence ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1339,6 +1355,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createFence" ); + return createResultValueType( static_cast( result ), fence ); } @@ -1356,6 +1373,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createFenceUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( fence, ObjectDestroy( *this, allocator, d ) ) ); } @@ -1426,6 +1444,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkResetFences( m_device, fences.size(), reinterpret_cast( fences.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1447,6 +1466,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceStatus", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1477,6 +1497,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1510,6 +1531,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &semaphore ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphore" ); + return createResultValueType( static_cast( result ), semaphore ); } @@ -1529,6 +1551,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &semaphore ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphoreUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( semaphore, ObjectDestroy( *this, allocator, d ) ) ); @@ -1609,6 +1632,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &event ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createEvent" ); + return createResultValueType( static_cast( result ), event ); } @@ -1626,6 +1650,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &event ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createEventUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( event, ObjectDestroy( *this, allocator, d ) ) ); } @@ -1695,6 +1720,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getEventStatus", { VULKAN_HPP_NAMESPACE::Result::eEventSet, VULKAN_HPP_NAMESPACE::Result::eEventReset } ); + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1715,6 +1741,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkSetEvent( m_device, static_cast( event ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::setEvent" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1734,6 +1761,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkResetEvent( m_device, static_cast( event ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::resetEvent" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1767,6 +1795,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &queryPool ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPool" ); + return createResultValueType( static_cast( result ), queryPool ); } @@ -1786,6 +1815,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &queryPool ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPoolUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( queryPool, ObjectDestroy( *this, allocator, d ) ) ); @@ -1886,6 +1916,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); + return ResultValue>( static_cast( result ), data ); } @@ -1911,6 +1942,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResult", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); + return ResultValue( static_cast( result ), data ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1942,6 +1974,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &buffer ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createBuffer" ); + return createResultValueType( static_cast( result ), buffer ); } @@ -1959,6 +1992,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &buffer ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( buffer, ObjectDestroy( *this, allocator, d ) ) ); } @@ -2040,6 +2074,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &view ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferView" ); + return createResultValueType( static_cast( result ), view ); } @@ -2059,6 +2094,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &view ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferViewUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( view, ObjectDestroy( *this, allocator, d ) ) ); } @@ -2138,6 +2174,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &image ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createImage" ); + return createResultValueType( static_cast( result ), image ); } @@ -2155,6 +2192,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &image ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createImageUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( image, ObjectDestroy( *this, allocator, d ) ) ); } @@ -2266,6 +2304,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &view ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createImageView" ); + return createResultValueType( static_cast( result ), view ); } @@ -2285,6 +2324,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &view ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createImageViewUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( view, ObjectDestroy( *this, allocator, d ) ) ); } @@ -2366,6 +2406,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &shaderModule ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModule" ); + return createResultValueType( static_cast( result ), shaderModule ); } @@ -2385,6 +2426,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &shaderModule ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModuleUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( shaderModule, ObjectDestroy( *this, allocator, d ) ) ); @@ -2467,6 +2509,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipelineCache ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCache" ); + return createResultValueType( static_cast( result ), pipelineCache ); } @@ -2486,6 +2529,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipelineCache ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCacheUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( pipelineCache, ObjectDestroy( *this, allocator, d ) ) ); @@ -2630,6 +2674,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkMergePipelineCaches( m_device, static_cast( dstCache ), srcCaches.size(), reinterpret_cast( srcCaches.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::mergePipelineCaches" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -2672,6 +2717,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue>( static_cast( result ), pipelines ); } @@ -2699,6 +2745,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue>( static_cast( result ), pipelines ); } @@ -2722,47 +2769,47 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipeline", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue( static_cast( result ), pipeline ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> Device::createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, Optional allocator, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, PipelineAllocator> uniquePipelines; - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateGraphicsPipelines( + + std::vector pipelines( createInfos.size() ); + VkResult result = d.vkCreateGraphicsPipelines( m_device, static_cast( pipelineCache ), createInfos.size(), reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( pipelines.data() ) ) ); - if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) + reinterpret_cast( pipelines.data() ) ); + resultCheck( static_cast( result ), + VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + std::vector, PipelineAllocator> uniquePipelines; + uniquePipelines.reserve( createInfos.size() ); + ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) { - uniquePipelines.reserve( createInfos.size() ); - ObjectDestroy deleter( *this, allocator, d ); - for ( size_t i = 0; i < createInfos.size(); i++ ) - { - uniquePipelines.push_back( UniqueHandle( pipelines[i], deleter ) ); - } + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); } - return createResultValue( result, - std::move( uniquePipelines ), - VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue, PipelineAllocator>>( + static_cast( result ), std::move( uniquePipelines ) ); } template >::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> Device::createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, Optional allocator, @@ -2770,28 +2817,27 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateGraphicsPipelines( + + std::vector pipelines( createInfos.size() ); + VkResult result = d.vkCreateGraphicsPipelines( m_device, static_cast( pipelineCache ), createInfos.size(), reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( pipelines.data() ) ) ); - if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) + reinterpret_cast( pipelines.data() ) ); + resultCheck( static_cast( result ), + VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); + uniquePipelines.reserve( createInfos.size() ); + ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) { - uniquePipelines.reserve( createInfos.size() ); - ObjectDestroy deleter( *this, allocator, d ); - for ( size_t i = 0; i < createInfos.size(); i++ ) - { - uniquePipelines.push_back( UniqueHandle( pipelines[i], deleter ) ); - } + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); } - return createResultValue( result, - std::move( uniquePipelines ), - VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue, PipelineAllocator>>( + static_cast( result ), std::move( uniquePipelines ) ); } template @@ -2814,6 +2860,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelineUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue>( static_cast( result ), UniqueHandle( pipeline, ObjectDestroy( *this, allocator, d ) ) ); @@ -2859,6 +2906,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue>( static_cast( result ), pipelines ); } @@ -2886,6 +2934,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue>( static_cast( result ), pipelines ); } @@ -2909,47 +2958,47 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipeline", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue( static_cast( result ), pipeline ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> Device::createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, Optional allocator, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, PipelineAllocator> uniquePipelines; - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateComputePipelines( + + std::vector pipelines( createInfos.size() ); + VkResult result = d.vkCreateComputePipelines( m_device, static_cast( pipelineCache ), createInfos.size(), reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( pipelines.data() ) ) ); - if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) + reinterpret_cast( pipelines.data() ) ); + resultCheck( static_cast( result ), + VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + std::vector, PipelineAllocator> uniquePipelines; + uniquePipelines.reserve( createInfos.size() ); + ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) { - uniquePipelines.reserve( createInfos.size() ); - ObjectDestroy deleter( *this, allocator, d ); - for ( size_t i = 0; i < createInfos.size(); i++ ) - { - uniquePipelines.push_back( UniqueHandle( pipelines[i], deleter ) ); - } + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); } - return createResultValue( result, - std::move( uniquePipelines ), - VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue, PipelineAllocator>>( + static_cast( result ), std::move( uniquePipelines ) ); } template >::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> Device::createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, Optional allocator, @@ -2957,28 +3006,27 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateComputePipelines( + + std::vector pipelines( createInfos.size() ); + VkResult result = d.vkCreateComputePipelines( m_device, static_cast( pipelineCache ), createInfos.size(), reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( pipelines.data() ) ) ); - if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) + reinterpret_cast( pipelines.data() ) ); + resultCheck( static_cast( result ), + VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); + uniquePipelines.reserve( createInfos.size() ); + ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) { - uniquePipelines.reserve( createInfos.size() ); - ObjectDestroy deleter( *this, allocator, d ); - for ( size_t i = 0; i < createInfos.size(); i++ ) - { - uniquePipelines.push_back( UniqueHandle( pipelines[i], deleter ) ); - } + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); } - return createResultValue( result, - std::move( uniquePipelines ), - VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue, PipelineAllocator>>( + static_cast( result ), std::move( uniquePipelines ) ); } template @@ -3001,6 +3049,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelineUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue>( static_cast( result ), UniqueHandle( pipeline, ObjectDestroy( *this, allocator, d ) ) ); @@ -3083,6 +3132,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipelineLayout ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayout" ); + return createResultValueType( static_cast( result ), pipelineLayout ); } @@ -3102,6 +3152,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &pipelineLayout ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayoutUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( pipelineLayout, ObjectDestroy( *this, allocator, d ) ) ); @@ -3182,6 +3233,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &sampler ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSampler" ); + return createResultValueType( static_cast( result ), sampler ); } @@ -3199,6 +3251,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &sampler ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( sampler, ObjectDestroy( *this, allocator, d ) ) ); } @@ -3280,6 +3333,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &setLayout ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayout" ); + return createResultValueType( static_cast( result ), setLayout ); } @@ -3299,6 +3353,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &setLayout ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayoutUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( setLayout, ObjectDestroy( *this, allocator, d ) ) ); @@ -3385,6 +3440,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorPool ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPool" ); + return createResultValueType( static_cast( result ), descriptorPool ); } @@ -3404,6 +3460,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorPool ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPoolUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( descriptorPool, ObjectDestroy( *this, allocator, d ) ) ); @@ -3500,6 +3557,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkAllocateDescriptorSets( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" ); + return createResultValueType( static_cast( result ), descriptorSets ); } @@ -3518,55 +3576,56 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkAllocateDescriptorSets( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" ); + return createResultValueType( static_cast( result ), descriptorSets ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, DescriptorSetAllocator>>::type - Device::allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, DescriptorSetAllocator>>::type + Device::allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, DescriptorSetAllocator> uniqueDescriptorSets; - std::vector descriptorSets( allocateInfo.descriptorSetCount ); - Result result = static_cast( d.vkAllocateDescriptorSets( - m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); - if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) + + std::vector descriptorSets( allocateInfo.descriptorSetCount ); + VkResult result = d.vkAllocateDescriptorSets( + m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); + std::vector, DescriptorSetAllocator> uniqueDescriptorSets; + uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount ); + PoolFree deleter( *this, allocateInfo.descriptorPool, d ); + for ( auto const & descriptorSet : descriptorSets ) { - uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount ); - PoolFree deleter( *this, allocateInfo.descriptorPool, d ); - for ( size_t i = 0; i < allocateInfo.descriptorSetCount; i++ ) - { - uniqueDescriptorSets.push_back( UniqueHandle( descriptorSets[i], deleter ) ); - } + uniqueDescriptorSets.push_back( UniqueHandle( descriptorSet, deleter ) ); } - return createResultValue( result, std::move( uniqueDescriptorSets ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); + return createResultValueType( static_cast( result ), std::move( uniqueDescriptorSets ) ); } template >::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, DescriptorSetAllocator>>::type - Device::allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, DescriptorSetAllocator>>::type + Device::allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, DescriptorSetAllocator & descriptorSetAllocator, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, DescriptorSetAllocator> uniqueDescriptorSets( descriptorSetAllocator ); - std::vector descriptorSets( allocateInfo.descriptorSetCount ); - Result result = static_cast( d.vkAllocateDescriptorSets( - m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); - if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) + + std::vector descriptorSets( allocateInfo.descriptorSetCount ); + VkResult result = d.vkAllocateDescriptorSets( + m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); + std::vector, DescriptorSetAllocator> uniqueDescriptorSets( descriptorSetAllocator ); + uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount ); + PoolFree deleter( *this, allocateInfo.descriptorPool, d ); + for ( auto const & descriptorSet : descriptorSets ) { - uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount ); - PoolFree deleter( *this, allocateInfo.descriptorPool, d ); - for ( size_t i = 0; i < allocateInfo.descriptorSetCount; i++ ) - { - uniqueDescriptorSets.push_back( UniqueHandle( descriptorSets[i], deleter ) ); - } + uniqueDescriptorSets.push_back( UniqueHandle( descriptorSet, deleter ) ); } - return createResultValue( result, std::move( uniqueDescriptorSets ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); + return createResultValueType( static_cast( result ), std::move( uniqueDescriptorSets ) ); } # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -3679,6 +3738,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &framebuffer ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebuffer" ); + return createResultValueType( static_cast( result ), framebuffer ); } @@ -3698,6 +3758,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &framebuffer ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebufferUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( framebuffer, ObjectDestroy( *this, allocator, d ) ) ); @@ -3780,6 +3841,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &renderPass ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass" ); + return createResultValueType( static_cast( result ), renderPass ); } @@ -3799,6 +3861,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &renderPass ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPassUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( renderPass, ObjectDestroy( *this, allocator, d ) ) ); @@ -3904,6 +3967,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &commandPool ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPool" ); + return createResultValueType( static_cast( result ), commandPool ); } @@ -3923,6 +3987,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &commandPool ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPoolUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( commandPool, ObjectDestroy( *this, allocator, d ) ) ); @@ -3994,6 +4059,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkResetCommandPool( m_device, static_cast( commandPool ), static_cast( flags ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::resetCommandPool" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -4019,6 +4085,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkAllocateCommandBuffers( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" ); + return createResultValueType( static_cast( result ), commandBuffers ); } @@ -4037,55 +4104,56 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkAllocateCommandBuffers( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" ); + return createResultValueType( static_cast( result ), commandBuffers ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, CommandBufferAllocator>>::type - Device::allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, CommandBufferAllocator>>::type + Device::allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, CommandBufferAllocator> uniqueCommandBuffers; - std::vector commandBuffers( allocateInfo.commandBufferCount ); - Result result = static_cast( d.vkAllocateCommandBuffers( - m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); - if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) + + std::vector commandBuffers( allocateInfo.commandBufferCount ); + VkResult result = d.vkAllocateCommandBuffers( + m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); + std::vector, CommandBufferAllocator> uniqueCommandBuffers; + uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount ); + PoolFree deleter( *this, allocateInfo.commandPool, d ); + for ( auto const & commandBuffer : commandBuffers ) { - uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount ); - PoolFree deleter( *this, allocateInfo.commandPool, d ); - for ( size_t i = 0; i < allocateInfo.commandBufferCount; i++ ) - { - uniqueCommandBuffers.push_back( UniqueHandle( commandBuffers[i], deleter ) ); - } + uniqueCommandBuffers.push_back( UniqueHandle( commandBuffer, deleter ) ); } - return createResultValue( result, std::move( uniqueCommandBuffers ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); + return createResultValueType( static_cast( result ), std::move( uniqueCommandBuffers ) ); } template >::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, CommandBufferAllocator>>::type - Device::allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, CommandBufferAllocator>>::type + Device::allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, CommandBufferAllocator & commandBufferAllocator, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, CommandBufferAllocator> uniqueCommandBuffers( commandBufferAllocator ); - std::vector commandBuffers( allocateInfo.commandBufferCount ); - Result result = static_cast( d.vkAllocateCommandBuffers( - m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); - if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) + + std::vector commandBuffers( allocateInfo.commandBufferCount ); + VkResult result = d.vkAllocateCommandBuffers( + m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); + std::vector, CommandBufferAllocator> uniqueCommandBuffers( commandBufferAllocator ); + uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount ); + PoolFree deleter( *this, allocateInfo.commandPool, d ); + for ( auto const & commandBuffer : commandBuffers ) { - uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount ); - PoolFree deleter( *this, allocateInfo.commandPool, d ); - for ( size_t i = 0; i < allocateInfo.commandBufferCount; i++ ) - { - uniqueCommandBuffers.push_back( UniqueHandle( commandBuffers[i], deleter ) ); - } + uniqueCommandBuffers.push_back( UniqueHandle( commandBuffer, deleter ) ); } - return createResultValue( result, std::move( uniqueCommandBuffers ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); + return createResultValueType( static_cast( result ), std::move( uniqueCommandBuffers ) ); } # endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -4155,6 +4223,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast( &beginInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -4174,6 +4243,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkEndCommandBuffer( m_commandBuffer ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -4194,6 +4264,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkResetCommandBuffer( m_commandBuffer, static_cast( flags ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5107,6 +5178,7 @@ namespace VULKAN_HPP_NAMESPACE uint32_t apiVersion; VkResult result = d.vkEnumerateInstanceVersion( &apiVersion ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceVersion" ); + return createResultValueType( static_cast( result ), apiVersion ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5129,6 +5201,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkBindBufferMemory2( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5151,6 +5224,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkBindImageMemory2( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5542,6 +5616,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &imageFormatInfo ), reinterpret_cast( &imageFormatProperties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); + return createResultValueType( static_cast( result ), imageFormatProperties ); } @@ -5557,6 +5632,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &imageFormatInfo ), reinterpret_cast( &imageFormatProperties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); + return createResultValueType( static_cast( result ), structureChain ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5817,6 +5893,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &ycbcrConversion ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion" ); + return createResultValueType( static_cast( result ), ycbcrConversion ); } @@ -5836,6 +5913,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &ycbcrConversion ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( ycbcrConversion, ObjectDestroy( *this, allocator, d ) ) ); @@ -5923,6 +6001,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorUpdateTemplate ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplate" ); + return createResultValueType( static_cast( result ), descriptorUpdateTemplate ); } @@ -5942,6 +6021,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorUpdateTemplate ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( descriptorUpdateTemplate, ObjectDestroy( *this, allocator, d ) ) ); @@ -6221,6 +6301,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &renderPass ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2" ); + return createResultValueType( static_cast( result ), renderPass ); } @@ -6240,6 +6321,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &renderPass ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2Unique" ); + return createResultValueType( static_cast( result ), UniqueHandle( renderPass, ObjectDestroy( *this, allocator, d ) ) ); @@ -6339,6 +6421,7 @@ namespace VULKAN_HPP_NAMESPACE uint64_t value; VkResult result = d.vkGetSemaphoreCounterValue( m_device, static_cast( semaphore ), &value ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValue" ); + return createResultValueType( static_cast( result ), value ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -6363,6 +6446,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -6384,6 +6468,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkSignalSemaphore( m_device, reinterpret_cast( &signalInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -6555,6 +6640,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &privateDataSlot ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlot" ); + return createResultValueType( static_cast( result ), privateDataSlot ); } @@ -6574,6 +6660,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &privateDataSlot ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( privateDataSlot, ObjectDestroy( *this, allocator, d ) ) ); @@ -6654,6 +6741,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkSetPrivateData( m_device, static_cast( objectType ), objectHandle, static_cast( privateDataSlot ), data ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateData" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -6797,6 +6885,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkQueueSubmit2( m_queue, submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -7341,6 +7430,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast( surface ), reinterpret_cast( &supported ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" ); + return createResultValueType( static_cast( result ), supported ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -7366,6 +7456,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast( surface ), reinterpret_cast( &surfaceCapabilities ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" ); + return createResultValueType( static_cast( result ), surfaceCapabilities ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -7557,6 +7648,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &swapchain ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHR" ); + return createResultValueType( static_cast( result ), swapchain ); } @@ -7576,6 +7668,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &swapchain ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( swapchain, ObjectDestroy( *this, allocator, d ) ) ); @@ -7732,6 +7825,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result::eTimeout, VULKAN_HPP_NAMESPACE::Result::eNotReady, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); + return ResultValue( static_cast( result ), imageIndex ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -7755,6 +7849,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -7779,6 +7874,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast( &deviceGroupPresentCapabilities ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" ); + return createResultValueType( static_cast( result ), deviceGroupPresentCapabilities ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -7804,6 +7900,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast( surface ), reinterpret_cast( &modes ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" ); + return createResultValueType( static_cast( result ), modes ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -7903,6 +8000,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result::eTimeout, VULKAN_HPP_NAMESPACE::Result::eNotReady, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); + return ResultValue( static_cast( result ), imageIndex ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -8238,6 +8336,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &mode ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHR" ); + return createResultValueType( static_cast( result ), mode ); } @@ -8259,6 +8358,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &mode ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( mode, ObjectDestroy( *this, allocator, d ) ) ); @@ -8289,6 +8389,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast( mode ), planeIndex, reinterpret_cast( &capabilities ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" ); + return createResultValueType( static_cast( result ), capabilities ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -8322,6 +8423,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR" ); + return createResultValueType( static_cast( result ), surface ); } @@ -8341,6 +8443,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); @@ -8382,6 +8485,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( swapchains.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" ); + return createResultValueType( static_cast( result ), swapchains ); } @@ -8405,6 +8509,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( swapchains.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" ); + return createResultValueType( static_cast( result ), swapchains ); } @@ -8424,66 +8529,67 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &swapchain ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHR" ); + return createResultValueType( static_cast( result ), swapchain ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, SwapchainKHRAllocator>>::type - Device::createSharedSwapchainsKHRUnique( ArrayProxy const & createInfos, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, SwapchainKHRAllocator>>::type + Device::createSharedSwapchainsKHRUnique( ArrayProxy const & createInfos, Optional allocator, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, SwapchainKHRAllocator> uniqueSwapchains; - std::vector swapchains( createInfos.size() ); - Result result = static_cast( d.vkCreateSharedSwapchainsKHR( + + std::vector swapchains( createInfos.size() ); + VkResult result = d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size(), reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( swapchains.data() ) ) ); - if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) + reinterpret_cast( swapchains.data() ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); + std::vector, SwapchainKHRAllocator> uniqueSwapchains; + uniqueSwapchains.reserve( createInfos.size() ); + ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & swapchain : swapchains ) { - uniqueSwapchains.reserve( createInfos.size() ); - ObjectDestroy deleter( *this, allocator, d ); - for ( size_t i = 0; i < createInfos.size(); i++ ) - { - uniqueSwapchains.push_back( UniqueHandle( swapchains[i], deleter ) ); - } + uniqueSwapchains.push_back( UniqueHandle( swapchain, deleter ) ); } - return createResultValue( result, std::move( uniqueSwapchains ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); + return createResultValueType( static_cast( result ), std::move( uniqueSwapchains ) ); } template >::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, SwapchainKHRAllocator>>::type - Device::createSharedSwapchainsKHRUnique( ArrayProxy const & createInfos, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, SwapchainKHRAllocator>>::type + Device::createSharedSwapchainsKHRUnique( ArrayProxy const & createInfos, Optional allocator, SwapchainKHRAllocator & swapchainKHRAllocator, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, SwapchainKHRAllocator> uniqueSwapchains( swapchainKHRAllocator ); - std::vector swapchains( createInfos.size() ); - Result result = static_cast( d.vkCreateSharedSwapchainsKHR( + + std::vector swapchains( createInfos.size() ); + VkResult result = d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size(), reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( swapchains.data() ) ) ); - if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) + reinterpret_cast( swapchains.data() ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); + std::vector, SwapchainKHRAllocator> uniqueSwapchains( swapchainKHRAllocator ); + uniqueSwapchains.reserve( createInfos.size() ); + ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & swapchain : swapchains ) { - uniqueSwapchains.reserve( createInfos.size() ); - ObjectDestroy deleter( *this, allocator, d ); - for ( size_t i = 0; i < createInfos.size(); i++ ) - { - uniqueSwapchains.push_back( UniqueHandle( swapchains[i], deleter ) ); - } + uniqueSwapchains.push_back( UniqueHandle( swapchain, deleter ) ); } - return createResultValue( result, std::move( uniqueSwapchains ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); + return createResultValueType( static_cast( result ), std::move( uniqueSwapchains ) ); } template @@ -8502,6 +8608,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &swapchain ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( swapchain, ObjectDestroy( *this, allocator, d ) ) ); @@ -8541,6 +8648,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR" ); + return createResultValueType( static_cast( result ), surface ); } @@ -8560,6 +8668,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); @@ -8621,6 +8730,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR" ); + return createResultValueType( static_cast( result ), surface ); } @@ -8640,6 +8750,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); @@ -8705,6 +8816,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR" ); + return createResultValueType( static_cast( result ), surface ); } @@ -8724,6 +8836,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); @@ -8786,6 +8899,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR" ); + return createResultValueType( static_cast( result ), surface ); } @@ -8805,6 +8919,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); @@ -8845,6 +8960,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR" ); + return createResultValueType( static_cast( result ), surface ); } @@ -8864,6 +8980,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); @@ -8911,6 +9028,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &callback ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT" ); + return createResultValueType( static_cast( result ), callback ); } @@ -8930,6 +9048,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &callback ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXTUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( callback, ObjectDestroy( *this, allocator, d ) ) ); @@ -9051,6 +9170,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast( &tagInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -9072,6 +9192,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast( &nameInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -9145,6 +9266,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetPhysicalDeviceVideoCapabilitiesKHR( m_physicalDevice, reinterpret_cast( &videoProfile ), reinterpret_cast( &capabilities ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); + return createResultValueType( static_cast( result ), capabilities ); } @@ -9159,6 +9281,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetPhysicalDeviceVideoCapabilitiesKHR( m_physicalDevice, reinterpret_cast( &videoProfile ), reinterpret_cast( &capabilities ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); + return createResultValueType( static_cast( result ), structureChain ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -9279,6 +9402,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &videoSession ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHR" ); + return createResultValueType( static_cast( result ), videoSession ); } @@ -9298,6 +9422,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &videoSession ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( videoSession, ObjectDestroy( *this, allocator, d ) ) ); @@ -9468,6 +9593,7 @@ namespace VULKAN_HPP_NAMESPACE videoSessionBindMemories.size(), reinterpret_cast( videoSessionBindMemories.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::bindVideoSessionMemoryKHR" ); + return createResultValueType( static_cast( result ) ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -9502,6 +9628,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &videoSessionParameters ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHR" ); + return createResultValueType( static_cast( result ), videoSessionParameters ); } @@ -9521,6 +9648,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &videoSessionParameters ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( videoSessionParameters, ObjectDestroy( *this, allocator, d ) ) ); @@ -9553,6 +9681,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( videoSessionParameters ), reinterpret_cast( &updateInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::updateVideoSessionParametersKHR" ); + return createResultValueType( static_cast( result ) ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -9888,6 +10017,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &module ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVX" ); + return createResultValueType( static_cast( result ), module ); } @@ -9907,6 +10037,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &module ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVXUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( module, ObjectDestroy( *this, allocator, d ) ) ); } @@ -9942,6 +10073,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &function ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVX" ); + return createResultValueType( static_cast( result ), function ); } @@ -9961,6 +10093,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &function ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVXUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( function, ObjectDestroy( *this, allocator, d ) ) ); @@ -10123,6 +10256,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetImageViewAddressNVX( m_device, static_cast( imageView ), reinterpret_cast( &properties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewAddressNVX" ); + return createResultValueType( static_cast( result ), properties ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -10332,6 +10466,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP" ); + return createResultValueType( static_cast( result ), surface ); } @@ -10351,6 +10486,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGPUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); @@ -10408,6 +10544,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( externalHandleType ), reinterpret_cast( &externalImageFormatProperties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" ); + return createResultValueType( static_cast( result ), externalImageFormatProperties ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -10437,6 +10574,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetMemoryWin32HandleNV( m_device, static_cast( memory ), static_cast( handleType ), &handle ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleNV" ); + return createResultValueType( static_cast( result ), handle ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -10575,6 +10713,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &imageFormatInfo ), reinterpret_cast( &imageFormatProperties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); + return createResultValueType( static_cast( result ), imageFormatProperties ); } @@ -10590,6 +10729,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &imageFormatInfo ), reinterpret_cast( &imageFormatProperties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); + return createResultValueType( static_cast( result ), structureChain ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -10870,6 +11010,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNN" ); + return createResultValueType( static_cast( result ), surface ); } @@ -10889,6 +11030,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNNUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); @@ -11037,6 +11179,7 @@ namespace VULKAN_HPP_NAMESPACE HANDLE handle; VkResult result = d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" ); + return createResultValueType( static_cast( result ), handle ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11068,6 +11211,7 @@ namespace VULKAN_HPP_NAMESPACE handle, reinterpret_cast( &memoryWin32HandleProperties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" ); + return createResultValueType( static_cast( result ), memoryWin32HandleProperties ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11094,6 +11238,7 @@ namespace VULKAN_HPP_NAMESPACE int fd; VkResult result = d.vkGetMemoryFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" ); + return createResultValueType( static_cast( result ), fd ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11120,6 +11265,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetMemoryFdPropertiesKHR( m_device, static_cast( handleType ), fd, reinterpret_cast( &memoryFdProperties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" ); + return createResultValueType( static_cast( result ), memoryFdProperties ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11178,6 +11324,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &importSemaphoreWin32HandleInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" ); + return createResultValueType( static_cast( result ) ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11201,6 +11348,7 @@ namespace VULKAN_HPP_NAMESPACE HANDLE handle; VkResult result = d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" ); + return createResultValueType( static_cast( result ), handle ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11225,6 +11373,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast( &importSemaphoreFdInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11248,6 +11397,7 @@ namespace VULKAN_HPP_NAMESPACE int fd; VkResult result = d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" ); + return createResultValueType( static_cast( result ), fd ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11380,6 +11530,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorUpdateTemplate ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHR" ); + return createResultValueType( static_cast( result ), descriptorUpdateTemplate ); } @@ -11399,6 +11550,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &descriptorUpdateTemplate ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( descriptorUpdateTemplate, ObjectDestroy( *this, allocator, d ) ) ); @@ -11523,6 +11675,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast( display ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" ); + return createResultValueType( static_cast( result ) ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11547,6 +11700,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DisplayKHR display; VkResult result = d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast( &display ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXT" ); + return createResultValueType( static_cast( result ), display ); } @@ -11560,6 +11714,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DisplayKHR display; VkResult result = d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast( &display ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXTUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( display, ObjectRelease( *this, d ) ) ); } @@ -11591,6 +11746,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast( surface ), reinterpret_cast( &surfaceCapabilities ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" ); + return createResultValueType( static_cast( result ), surfaceCapabilities ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11618,6 +11774,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkDisplayPowerControlEXT( m_device, static_cast( display ), reinterpret_cast( &displayPowerInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11651,6 +11808,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXT" ); + return createResultValueType( static_cast( result ), fence ); } @@ -11670,6 +11828,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXTUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( fence, ObjectDestroy( *this, allocator, d ) ) ); } @@ -11709,6 +11868,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXT" ); + return createResultValueType( static_cast( result ), fence ); } @@ -11730,6 +11890,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &fence ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXTUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( fence, ObjectDestroy( *this, allocator, d ) ) ); } @@ -11758,6 +11919,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetSwapchainCounterEXT( m_device, static_cast( swapchain ), static_cast( counter ), &counterValue ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainCounterEXT" ); + return createResultValueType( static_cast( result ), counterValue ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11786,6 +11948,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast( swapchain ), reinterpret_cast( &displayTimingProperties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getRefreshCycleDurationGOOGLE" ); + return createResultValueType( static_cast( result ), displayTimingProperties ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11967,6 +12130,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &renderPass ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHR" ); + return createResultValueType( static_cast( result ), renderPass ); } @@ -11986,6 +12150,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &renderPass ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( renderPass, ObjectDestroy( *this, allocator, d ) ) ); @@ -12079,6 +12244,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainStatusKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -12134,6 +12300,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast( &importFenceWin32HandleInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" ); + return createResultValueType( static_cast( result ) ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -12158,6 +12325,7 @@ namespace VULKAN_HPP_NAMESPACE HANDLE handle; VkResult result = d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" ); + return createResultValueType( static_cast( result ), handle ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -12182,6 +12350,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkImportFenceFdKHR( m_device, reinterpret_cast( &importFenceFdInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -12205,6 +12374,7 @@ namespace VULKAN_HPP_NAMESPACE int fd; VkResult result = d.vkGetFenceFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" ); + return createResultValueType( static_cast( result ), fd ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -12362,6 +12532,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast( &info ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -12399,6 +12570,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surfaceInfo ), reinterpret_cast( &surfaceCapabilities ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); + return createResultValueType( static_cast( result ), surfaceCapabilities ); } @@ -12414,6 +12586,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surfaceInfo ), reinterpret_cast( &surfaceCapabilities ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); + return createResultValueType( static_cast( result ), structureChain ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -12750,6 +12923,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &displayPlaneInfo ), reinterpret_cast( &capabilities ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" ); + return createResultValueType( static_cast( result ), capabilities ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -12786,6 +12960,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVK" ); + return createResultValueType( static_cast( result ), surface ); } @@ -12805,6 +12980,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVKUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); @@ -12845,6 +13021,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVK" ); + return createResultValueType( static_cast( result ), surface ); } @@ -12864,6 +13041,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVKUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); @@ -12891,6 +13069,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast( &nameInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -12912,6 +13091,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast( &tagInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -13036,6 +13216,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &messenger ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT" ); + return createResultValueType( static_cast( result ), messenger ); } @@ -13055,6 +13236,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &messenger ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXTUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( messenger, ObjectDestroy( *this, allocator, d ) ) ); @@ -13166,6 +13348,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, &buffer, reinterpret_cast( &properties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); + return createResultValueType( static_cast( result ), properties ); } @@ -13181,6 +13364,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, &buffer, reinterpret_cast( &properties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); + return createResultValueType( static_cast( result ), structureChain ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -13207,6 +13391,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast( &info ), &buffer ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" ); + return createResultValueType( static_cast( result ), buffer ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -13431,6 +13616,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &accelerationStructure ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHR" ); + return createResultValueType( static_cast( result ), accelerationStructure ); } @@ -13450,6 +13636,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &accelerationStructure ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( accelerationStructure, ObjectDestroy( *this, allocator, d ) ) ); @@ -13645,6 +13832,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -13674,6 +13862,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -13704,6 +13893,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -13734,6 +13924,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -13779,6 +13970,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( data.data() ), stride ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" ); + return createResultValueType( static_cast( result ), data ); } @@ -13800,6 +13992,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &data ), stride ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" ); + return createResultValueType( static_cast( result ), data ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -14027,6 +14220,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &ycbcrConversion ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHR" ); + return createResultValueType( static_cast( result ), ycbcrConversion ); } @@ -14046,6 +14240,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &ycbcrConversion ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( ycbcrConversion, ObjectDestroy( *this, allocator, d ) ) ); @@ -14098,6 +14293,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkBindBufferMemory2KHR( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -14120,6 +14316,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkBindImageMemory2KHR( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -14146,6 +14343,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast( image ), reinterpret_cast( &properties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getImageDrmFormatModifierPropertiesEXT" ); + return createResultValueType( static_cast( result ), properties ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -14181,6 +14379,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &validationCache ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXT" ); + return createResultValueType( static_cast( result ), validationCache ); } @@ -14200,6 +14399,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &validationCache ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXTUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( validationCache, ObjectDestroy( *this, allocator, d ) ) ); @@ -14278,6 +14478,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkMergeValidationCachesEXT( m_device, static_cast( dstCache ), srcCaches.size(), reinterpret_cast( srcCaches.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::mergeValidationCachesEXT" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -14448,6 +14649,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &accelerationStructure ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNV" ); + return createResultValueType( static_cast( result ), accelerationStructure ); } @@ -14467,6 +14669,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &accelerationStructure ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNVUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( accelerationStructure, ObjectDestroy( *this, allocator, d ) ) ); @@ -14589,6 +14792,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkBindAccelerationStructureMemoryNV( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -14728,6 +14932,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue>( static_cast( result ), pipelines ); } @@ -14755,6 +14960,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue>( static_cast( result ), pipelines ); } @@ -14778,47 +14984,47 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNV", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue( static_cast( result ), pipeline ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> Device::createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, Optional allocator, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, PipelineAllocator> uniquePipelines; - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateRayTracingPipelinesNV( + + std::vector pipelines( createInfos.size() ); + VkResult result = d.vkCreateRayTracingPipelinesNV( m_device, static_cast( pipelineCache ), createInfos.size(), reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( pipelines.data() ) ) ); - if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) + reinterpret_cast( pipelines.data() ) ); + resultCheck( static_cast( result ), + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + std::vector, PipelineAllocator> uniquePipelines; + uniquePipelines.reserve( createInfos.size() ); + ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) { - uniquePipelines.reserve( createInfos.size() ); - ObjectDestroy deleter( *this, allocator, d ); - for ( size_t i = 0; i < createInfos.size(); i++ ) - { - uniquePipelines.push_back( UniqueHandle( pipelines[i], deleter ) ); - } + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); } - return createResultValue( result, - std::move( uniquePipelines ), - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue, PipelineAllocator>>( + static_cast( result ), std::move( uniquePipelines ) ); } template >::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> Device::createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, Optional allocator, @@ -14826,28 +15032,27 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateRayTracingPipelinesNV( + + std::vector pipelines( createInfos.size() ); + VkResult result = d.vkCreateRayTracingPipelinesNV( m_device, static_cast( pipelineCache ), createInfos.size(), reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( pipelines.data() ) ) ); - if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) + reinterpret_cast( pipelines.data() ) ); + resultCheck( static_cast( result ), + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); + uniquePipelines.reserve( createInfos.size() ); + ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) { - uniquePipelines.reserve( createInfos.size() ); - ObjectDestroy deleter( *this, allocator, d ); - for ( size_t i = 0; i < createInfos.size(); i++ ) - { - uniquePipelines.push_back( UniqueHandle( pipelines[i], deleter ) ); - } + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); } - return createResultValue( result, - std::move( uniquePipelines ), - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue, PipelineAllocator>>( + static_cast( result ), std::move( uniquePipelines ) ); } template @@ -14870,6 +15075,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNVUnique", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue>( static_cast( result ), UniqueHandle( pipeline, ObjectDestroy( *this, allocator, d ) ) ); @@ -14902,6 +15108,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" ); + return createResultValueType( static_cast( result ), data ); } @@ -14915,6 +15122,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleNV" ); + return createResultValueType( static_cast( result ), data ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -14942,6 +15150,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetAccelerationStructureHandleNV( m_device, static_cast( accelerationStructure ), data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); + return createResultValueType( static_cast( result ), data ); } @@ -14955,6 +15164,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetAccelerationStructureHandleNV( m_device, static_cast( accelerationStructure ), sizeof( DataType ), reinterpret_cast( &data ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); + return createResultValueType( static_cast( result ), data ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15014,6 +15224,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkCompileDeferredNV( m_device, static_cast( pipeline ), shader ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::compileDeferredNV" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15132,6 +15343,7 @@ namespace VULKAN_HPP_NAMESPACE pHostPointer, reinterpret_cast( &memoryHostPointerProperties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" ); + return createResultValueType( static_cast( result ), memoryHostPointerProperties ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15254,6 +15466,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetCalibratedTimestampsEXT( m_device, timestampInfos.size(), reinterpret_cast( timestampInfos.data() ), timestamps.data(), &maxDeviation ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); + return createResultValueType( static_cast( result ), data ); } @@ -15275,6 +15488,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetCalibratedTimestampsEXT( m_device, timestampInfos.size(), reinterpret_cast( timestampInfos.data() ), timestamps.data(), &maxDeviation ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); + return createResultValueType( static_cast( result ), data ); } @@ -15290,6 +15504,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetCalibratedTimestampsEXT( m_device, 1, reinterpret_cast( ×tampInfo ), ×tamp, &maxDeviation ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" ); + return createResultValueType( static_cast( result ), data ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15444,6 +15659,7 @@ namespace VULKAN_HPP_NAMESPACE uint64_t value; VkResult result = d.vkGetSemaphoreCounterValueKHR( m_device, static_cast( semaphore ), &value ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValueKHR" ); + return createResultValueType( static_cast( result ), value ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15468,6 +15684,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15489,6 +15706,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkSignalSemaphoreKHR( m_device, reinterpret_cast( &signalInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15513,6 +15731,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkInitializePerformanceApiINTEL( m_device, reinterpret_cast( &initializeInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15541,6 +15760,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkCmdSetPerformanceMarkerINTEL( m_commandBuffer, reinterpret_cast( &markerInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15563,6 +15783,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkCmdSetPerformanceStreamMarkerINTEL( m_commandBuffer, reinterpret_cast( &markerInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15585,6 +15806,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkCmdSetPerformanceOverrideINTEL( m_commandBuffer, reinterpret_cast( &overrideInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15613,6 +15835,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &acquireInfo ), reinterpret_cast( &configuration ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL" ); + return createResultValueType( static_cast( result ), configuration ); } @@ -15629,6 +15852,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &acquireInfo ), reinterpret_cast( &configuration ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTELUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( configuration, ObjectRelease( *this, d ) ) ); @@ -15653,6 +15877,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast( configuration ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::releasePerformanceConfigurationINTEL" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15674,6 +15899,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast( configuration ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::release" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15695,6 +15921,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkQueueSetPerformanceConfigurationINTEL( m_queue, static_cast( configuration ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15720,6 +15947,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetPerformanceParameterINTEL( m_device, static_cast( parameter ), reinterpret_cast( &value ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" ); + return createResultValueType( static_cast( result ), value ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15768,6 +15996,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIA" ); + return createResultValueType( static_cast( result ), surface ); } @@ -15787,6 +16016,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIAUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); @@ -15827,6 +16057,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXT" ); + return createResultValueType( static_cast( result ), surface ); } @@ -15846,6 +16077,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXTUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); @@ -16078,6 +16310,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresentKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -16340,6 +16573,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast( swapchain ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::acquireFullScreenExclusiveModeEXT" ); + return createResultValueType( static_cast( result ) ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -16361,6 +16595,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast( swapchain ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::releaseFullScreenExclusiveModeEXT" ); + return createResultValueType( static_cast( result ) ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -16387,6 +16622,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetDeviceGroupSurfacePresentModes2EXT( m_device, reinterpret_cast( &surfaceInfo ), reinterpret_cast( &modes ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" ); + return createResultValueType( static_cast( result ), modes ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -16423,6 +16659,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXT" ); + return createResultValueType( static_cast( result ), surface ); } @@ -16442,6 +16679,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXTUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); @@ -16735,6 +16973,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &deferredOperation ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHR" ); + return createResultValueType( static_cast( result ), deferredOperation ); } @@ -16751,6 +16990,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &deferredOperation ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHRUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( deferredOperation, ObjectDestroy( *this, allocator, d ) ) ); @@ -16856,6 +17096,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::deferredOperationJoinKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR, VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR } ); + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -17251,6 +17492,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &indirectCommandsLayout ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNV" ); + return createResultValueType( static_cast( result ), indirectCommandsLayout ); } @@ -17270,6 +17512,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &indirectCommandsLayout ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNVUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( indirectCommandsLayout, ObjectDestroy( *this, allocator, d ) ) ); @@ -17347,6 +17590,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkAcquireDrmDisplayEXT( m_physicalDevice, drmFd, static_cast( display ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -17371,6 +17615,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DisplayKHR display; VkResult result = d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast( &display ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXT" ); + return createResultValueType( static_cast( result ), display ); } @@ -17384,6 +17629,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DisplayKHR display; VkResult result = d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast( &display ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXTUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( display, ObjectRelease( *this, d ) ) ); } @@ -17421,6 +17667,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &privateDataSlot ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXT" ); + return createResultValueType( static_cast( result ), privateDataSlot ); } @@ -17440,6 +17687,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &privateDataSlot ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXTUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( privateDataSlot, ObjectDestroy( *this, allocator, d ) ) ); @@ -17496,6 +17744,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkSetPrivateDataEXT( m_device, static_cast( objectType ), objectHandle, static_cast( privateDataSlot ), data ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -17665,6 +17914,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkQueueSubmit2KHR( m_queue, submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" ); + return createResultValueType( static_cast( result ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -17875,6 +18125,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast( display ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV" ); + return createResultValueType( static_cast( result ) ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -17898,6 +18149,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DisplayKHR display; VkResult result = d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast( &display ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" ); + return createResultValueType( static_cast( result ), display ); } @@ -17911,6 +18163,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DisplayKHR display; VkResult result = d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast( &display ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( display, ObjectRelease( *this, d ) ) ); } @@ -17950,6 +18203,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT" ); + return createResultValueType( static_cast( result ), surface ); } @@ -17969,6 +18223,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXTUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); @@ -18092,6 +18347,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue>( static_cast( result ), pipelines ); } @@ -18124,6 +18380,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue>( static_cast( result ), pipelines ); } @@ -18152,12 +18409,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue( static_cast( result ), pipeline ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> Device::createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, @@ -18165,40 +18423,38 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, PipelineAllocator> uniquePipelines; - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( + + std::vector pipelines( createInfos.size() ); + VkResult result = d.vkCreateRayTracingPipelinesKHR( m_device, static_cast( deferredOperation ), static_cast( pipelineCache ), createInfos.size(), reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( pipelines.data() ) ) ); - if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) || - ( result == VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) + reinterpret_cast( pipelines.data() ) ); + resultCheck( static_cast( result ), + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, + VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, + VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, + VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + std::vector, PipelineAllocator> uniquePipelines; + uniquePipelines.reserve( createInfos.size() ); + ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) { - uniquePipelines.reserve( createInfos.size() ); - ObjectDestroy deleter( *this, allocator, d ); - for ( size_t i = 0; i < createInfos.size(); i++ ) - { - uniquePipelines.push_back( UniqueHandle( pipelines[i], deleter ) ); - } + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); } - return createResultValue( result, - std::move( uniquePipelines ), - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, - VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, - VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, - VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue, PipelineAllocator>>( + static_cast( result ), std::move( uniquePipelines ) ); } template >::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> Device::createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, @@ -18207,33 +18463,31 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( + + std::vector pipelines( createInfos.size() ); + VkResult result = d.vkCreateRayTracingPipelinesKHR( m_device, static_cast( deferredOperation ), static_cast( pipelineCache ), createInfos.size(), reinterpret_cast( createInfos.data() ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( pipelines.data() ) ) ); - if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || ( result == VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) || - ( result == VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) || ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) + reinterpret_cast( pipelines.data() ) ); + resultCheck( static_cast( result ), + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, + VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, + VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, + VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); + uniquePipelines.reserve( createInfos.size() ); + ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) { - uniquePipelines.reserve( createInfos.size() ); - ObjectDestroy deleter( *this, allocator, d ); - for ( size_t i = 0; i < createInfos.size(); i++ ) - { - uniquePipelines.push_back( UniqueHandle( pipelines[i], deleter ) ); - } + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); } - return createResultValue( result, - std::move( uniquePipelines ), - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, - VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, - VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, - VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue, PipelineAllocator>>( + static_cast( result ), std::move( uniquePipelines ) ); } template @@ -18261,6 +18515,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + return ResultValue>( static_cast( result ), UniqueHandle( pipeline, ObjectDestroy( *this, allocator, d ) ) ); @@ -18293,6 +18548,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetRayTracingShaderGroupHandlesKHR( m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" ); + return createResultValueType( static_cast( result ), data ); } @@ -18306,6 +18562,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetRayTracingShaderGroupHandlesKHR( m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleKHR" ); + return createResultValueType( static_cast( result ), data ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -18336,6 +18593,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" ); + return createResultValueType( static_cast( result ), data ); } @@ -18349,6 +18607,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandleKHR" ); + return createResultValueType( static_cast( result ), data ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -18467,6 +18726,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetMemoryZirconHandleFUCHSIA( m_device, reinterpret_cast( &getZirconHandleInfo ), &zirconHandle ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" ); + return createResultValueType( static_cast( result ), zirconHandle ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -18501,6 +18761,7 @@ namespace VULKAN_HPP_NAMESPACE zirconHandle, reinterpret_cast( &memoryZirconHandleProperties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" ); + return createResultValueType( static_cast( result ), memoryZirconHandleProperties ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -18529,6 +18790,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkImportSemaphoreZirconHandleFUCHSIA( m_device, reinterpret_cast( &importSemaphoreZirconHandleInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" ); + return createResultValueType( static_cast( result ) ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -18555,6 +18817,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetSemaphoreZirconHandleFUCHSIA( m_device, reinterpret_cast( &getZirconHandleInfo ), &zirconHandle ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" ); + return createResultValueType( static_cast( result ), zirconHandle ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -18593,6 +18856,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &collection ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIA" ); + return createResultValueType( static_cast( result ), collection ); } @@ -18612,6 +18876,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &collection ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIAUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( collection, ObjectDestroy( *this, allocator, d ) ) ); @@ -18642,6 +18907,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkSetBufferCollectionImageConstraintsFUCHSIA( m_device, static_cast( collection ), reinterpret_cast( &imageConstraintsInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::setBufferCollectionImageConstraintsFUCHSIA" ); + return createResultValueType( static_cast( result ) ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -18669,6 +18935,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkSetBufferCollectionBufferConstraintsFUCHSIA( m_device, static_cast( collection ), reinterpret_cast( &bufferConstraintsInfo ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::setBufferCollectionBufferConstraintsFUCHSIA" ); + return createResultValueType( static_cast( result ) ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -18745,6 +19012,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetBufferCollectionPropertiesFUCHSIA( m_device, static_cast( collection ), reinterpret_cast( &properties ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferCollectionPropertiesFUCHSIA" ); + return createResultValueType( static_cast( result ), properties ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -18775,6 +19043,7 @@ namespace VULKAN_HPP_NAMESPACE resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSubpassShadingMaxWorkgroupSizeHUAWEI", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete } ); + return ResultValue( static_cast( result ), maxWorkgroupSize ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -18821,6 +19090,7 @@ namespace VULKAN_HPP_NAMESPACE VkResult result = d.vkGetMemoryRemoteAddressNV( m_device, reinterpret_cast( &memoryGetRemoteAddressInfo ), reinterpret_cast( &address ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" ); + return createResultValueType( static_cast( result ), address ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -18896,6 +19166,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNX" ); + return createResultValueType( static_cast( result ), surface ); } @@ -18915,6 +19186,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &surface ) ); resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNXUnique" ); + return createResultValueType( static_cast( result ), UniqueHandle( surface, ObjectDestroy( *this, allocator, d ) ) ); diff --git a/vulkan/vulkan_handles.hpp b/vulkan/vulkan_handles.hpp index 3b422ef..62309cd 100644 --- a/vulkan/vulkan_handles.hpp +++ b/vulkan/vulkan_handles.hpp @@ -7940,17 +7940,18 @@ namespace VULKAN_HPP_NAMESPACE Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE - template >> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + template >> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template >, + typename PipelineAllocator = std::allocator>, typename B = PipelineAllocator, typename std::enable_if>::value, int>::type = 0> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, Optional allocator, @@ -7996,17 +7997,18 @@ namespace VULKAN_HPP_NAMESPACE Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE - template >> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + template >> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template >, + typename PipelineAllocator = std::allocator>, typename B = PipelineAllocator, typename std::enable_if>::value, int>::type = 0> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, Optional allocator, @@ -8241,15 +8243,16 @@ namespace VULKAN_HPP_NAMESPACE DescriptorSetAllocator & descriptorSetAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE - template >> - VULKAN_HPP_NODISCARD typename ResultValueType, DescriptorSetAllocator>>::type + template >> + VULKAN_HPP_NODISCARD typename ResultValueType, DescriptorSetAllocator>>::type allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template >, + typename DescriptorSetAllocator = std::allocator>, typename B = DescriptorSetAllocator, typename std::enable_if>::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType, DescriptorSetAllocator>>::type + VULKAN_HPP_NODISCARD typename ResultValueType, DescriptorSetAllocator>>::type allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo, DescriptorSetAllocator & descriptorSetAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; @@ -8460,15 +8463,16 @@ namespace VULKAN_HPP_NAMESPACE CommandBufferAllocator & commandBufferAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE - template >> - VULKAN_HPP_NODISCARD typename ResultValueType, CommandBufferAllocator>>::type + template >> + VULKAN_HPP_NODISCARD typename ResultValueType, CommandBufferAllocator>>::type allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template >, + typename CommandBufferAllocator = std::allocator>, typename B = CommandBufferAllocator, typename std::enable_if>::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType, CommandBufferAllocator>>::type + VULKAN_HPP_NODISCARD typename ResultValueType, CommandBufferAllocator>>::type allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo, CommandBufferAllocator & commandBufferAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; @@ -9061,16 +9065,17 @@ namespace VULKAN_HPP_NAMESPACE Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE - template >> - VULKAN_HPP_NODISCARD typename ResultValueType, SwapchainKHRAllocator>>::type + template >> + VULKAN_HPP_NODISCARD typename ResultValueType, SwapchainKHRAllocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy const & createInfos, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template >, + typename SwapchainKHRAllocator = std::allocator>, typename B = SwapchainKHRAllocator, typename std::enable_if>::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType, SwapchainKHRAllocator>>::type + VULKAN_HPP_NODISCARD typename ResultValueType, SwapchainKHRAllocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy const & createInfos, Optional allocator, SwapchainKHRAllocator & swapchainKHRAllocator, @@ -10272,17 +10277,18 @@ namespace VULKAN_HPP_NAMESPACE Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE - template >> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + template >> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template >, + typename PipelineAllocator = std::allocator>, typename B = PipelineAllocator, typename std::enable_if>::value, int>::type = 0> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, Optional allocator, @@ -10898,18 +10904,19 @@ namespace VULKAN_HPP_NAMESPACE Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; # ifndef VULKAN_HPP_NO_SMART_HANDLE - template >> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + template >> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template >, + typename PipelineAllocator = std::allocator>, typename B = PipelineAllocator, typename std::enable_if>::value, int>::type = 0> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, ArrayProxy const & createInfos, diff --git a/vulkan/vulkan_structs.hpp b/vulkan/vulkan_structs.hpp index 0082dc7..a8e0b5c 100644 --- a/vulkan/vulkan_structs.hpp +++ b/vulkan/vulkan_structs.hpp @@ -2611,10 +2611,10 @@ namespace VULKAN_HPP_NAMESPACE public: VULKAN_HPP_NAMESPACE::TransformMatrixKHR transform = {}; - uint32_t instanceCustomIndex : 24; - uint32_t mask : 8; + uint32_t instanceCustomIndex : 24; + uint32_t mask : 8; uint32_t instanceShaderBindingTableRecordOffset : 24; - VkGeometryInstanceFlagsKHR flags : 8; + VkGeometryInstanceFlagsKHR flags : 8; uint64_t accelerationStructureReference = {}; }; VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR ) == sizeof( VkAccelerationStructureInstanceKHR ), @@ -2763,10 +2763,10 @@ namespace VULKAN_HPP_NAMESPACE public: VULKAN_HPP_NAMESPACE::TransformMatrixKHR transformT0 = {}; VULKAN_HPP_NAMESPACE::TransformMatrixKHR transformT1 = {}; - uint32_t instanceCustomIndex : 24; - uint32_t mask : 8; + uint32_t instanceCustomIndex : 24; + uint32_t mask : 8; uint32_t instanceShaderBindingTableRecordOffset : 24; - VkGeometryInstanceFlagsKHR flags : 8; + VkGeometryInstanceFlagsKHR flags : 8; uint64_t accelerationStructureReference = {}; }; VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV ) == @@ -3380,10 +3380,10 @@ namespace VULKAN_HPP_NAMESPACE public: VULKAN_HPP_NAMESPACE::SRTDataNV transformT0 = {}; VULKAN_HPP_NAMESPACE::SRTDataNV transformT1 = {}; - uint32_t instanceCustomIndex : 24; - uint32_t mask : 8; + uint32_t instanceCustomIndex : 24; + uint32_t mask : 8; uint32_t instanceShaderBindingTableRecordOffset : 24; - VkGeometryInstanceFlagsKHR flags : 8; + VkGeometryInstanceFlagsKHR flags : 8; uint64_t accelerationStructureReference = {}; }; VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV ) == sizeof( VkAccelerationStructureSRTMotionInstanceNV ),