From a8d47f469433a6e43e160ebbcfa9eee90b9d1c40 Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Thu, 24 Mar 2022 10:52:24 +0100 Subject: [PATCH] Combine two types of commands into one generation function. --- VulkanHppGenerator.cpp | 671 ++++++++------- VulkanHppGenerator.hpp | 20 +- vulkan/vulkan.hpp | 95 +-- vulkan/vulkan_funcs.hpp | 1632 +++++++++++++++++++++---------------- vulkan/vulkan_handles.hpp | 153 ++-- 5 files changed, 1426 insertions(+), 1145 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index 834eaf6..cd53767 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -38,7 +38,6 @@ std::pair generateEnumSuffixes( std::string const & na std::string generateEnumValueName( std::string const & enumName, std::string const & valueName, bool bitmask, std::set const & tags ); std::string generateNamespacedType( std::string const & type ); std::string generateNoDiscard( bool returnsSomething, bool multiSuccessCodes, bool multiErrorCodes ); -std::string generateReturnType( std::vector const & successCodes, std::string const & baseType ); std::string generateStandardArray( std::string const & type, std::vector const & sizes ); std::string generateStandardArrayWrapper( std::string const & type, std::vector const & sizes ); std::string generateSuccessCode( std::string const & code, std::set const & tags ); @@ -3119,142 +3118,6 @@ std::string VulkanHppGenerator::generateCommandName( std::string const & return commandName; } -std::string VulkanHppGenerator::generateCommandResult( std::string const & name, - CommandData const & commandData, - size_t initialSkipCount, - bool definition, - std::map const & vectorParams, - std::vector const & returnParams, - bool singular ) const -{ - assert( commandData.returnType == "VkResult" ); - assert( returnParams.size() <= 2 ); - assert( !singular || ( returnParams.size() == 1 ) ); // if singular is true, then there is one returnParam ! - - std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags ); - - std::set skippedParams = determineSkippedParams( commandData.params, initialSkipCount, vectorParams, returnParams, singular ); - // special handling for vkGetMemoryHostPointerPropertiesEXT: here, we really need to stick with the const void * parameter ! - std::set templatedParams = ( name == "vkGetMemoryHostPointerPropertiesEXT" ) ? std::set() : determineVoidPointerParams( commandData.params ); - std::set singularParams; - if ( singular ) - { - singularParams = determineSingularParams( returnParams[0], vectorParams ); - commandName = stripPluralS( commandName ); - } - - std::string argumentList = generateArgumentListEnhanced( commandData.params, skippedParams, singularParams, templatedParams, definition, false, false, true ); - std::string argumentTemplates = generateArgumentTemplates( commandData.params, templatedParams, false ); - std::string chainTemplates = ""; - std::string nodiscard = generateNoDiscard( !returnParams.empty(), 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); - std::string noexceptString = commandData.errorCodes.empty() ? " VULKAN_HPP_NOEXCEPT" : ""; - - std::vector dataTypes; - for ( auto rp : returnParams ) - { - dataTypes.push_back( ( templatedParams.find( rp ) != templatedParams.end() ) - ? ( stripPrefix( commandData.params[rp].name, "p" ) + "Type" ) - : stripPostfix( commandData.params[rp].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ) ); - } - std::string dataType; - switch ( dataTypes.size() ) - { - case 0: break; - case 1: dataType = dataTypes[0]; break; - case 2: dataType = "std::pair<" + dataTypes[0] + ", " + dataTypes[1] + ">"; break; - default: assert( false ); break; - } - std::string returnType = generateReturnType( commandData.successCodes, dataType.empty() ? "void" : dataType ); - - if ( definition ) - { - std::string dataDeclarations, dataResult; - switch ( returnParams.size() ) - { - case 0: break; - case 1: - { - std::string dataVariable = startLowerCase( stripPrefix( commandData.params[returnParams[0]].name, "p" ) ); - if ( singular ) - { - dataVariable = stripPluralS( dataVariable ); - } - - std::string const dataDeclarationTemplate = R"(${dataType} ${dataVariable};)"; - dataDeclarations = replaceWithMap( dataDeclarationTemplate, { { "dataType", dataType }, { "dataVariable", dataVariable } } ); - - std::string const dataResultTemplate = R"(${dataVariable}, )"; - dataResult = replaceWithMap( dataResultTemplate, { { "dataVariable", dataVariable } } ); - } - break; - case 2: - { - std::string const dataDeclarationTemplate = R"(${dataType} data; - ${firstDataType} & ${firstDataName} = data.first; - ${secondDataType} & ${secondDataName} = data.second;)"; - - dataDeclarations = replaceWithMap( dataDeclarationTemplate, - { { "dataType", dataType }, - { "firstDataName", startLowerCase( stripPrefix( commandData.params[returnParams[0]].name, "p" ) ) }, - { "firstDataType", dataTypes[0] }, - { "secondDataName", startLowerCase( stripPrefix( commandData.params[returnParams[1]].name, "p" ) ) }, - { "secondDataType", dataTypes[1] } } ); - dataResult = "data, "; - } - break; - default: assert( false ); break; - } - - std::string const functionTemplate = - R"( template <${argumentTemplates}${chainTemplates}typename Dispatch> - ${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}${classSeparator}${commandName}( ${argumentList} )${const}${noexcept} - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -${vectorSizeCheck} - ${dataDeclarations} - Result result = static_cast( d.${vkCommand}( ${callArguments} ) ); - return createResultValue( result, ${dataResult}VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} ); - })"; - - std::pair>> vectorSizeCheck = needsVectorSizeCheck( commandData.params, vectorParams, singularParams ); - return replaceWithMap( - functionTemplate, - { { "argumentList", argumentList }, - { "argumentTemplates", argumentTemplates }, - { "callArguments", generateCallArgumentsEnhanced( commandData, initialSkipCount, false, singularParams, templatedParams, false ) }, - { "chainTemplates", chainTemplates }, - { "className", initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, - { "classSeparator", commandData.handle.empty() ? "" : "::" }, - { "commandName", commandName }, - { "const", commandData.handle.empty() ? "" : " const" }, - { "dataDeclarations", dataDeclarations }, - { "dataResult", dataResult }, - { "nodiscard", nodiscard }, - { "noexcept", noexceptString }, - { "returnType", returnType }, - { "successCodeList", generateSuccessCodeList( commandData.successCodes ) }, - { "vectorSizeCheck", - vectorSizeCheck.first ? generateVectorSizeCheck( name, commandData, initialSkipCount, vectorSizeCheck.second, skippedParams, false ) : "" }, - { "vkCommand", name } } ); - } - else - { - std::string const functionTemplate = - R"( template <${argumentTemplates}${chainTemplates}typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - ${nodiscard}${returnType} ${commandName}( ${argumentList} )${const}${noexcept};)"; - - return replaceWithMap( functionTemplate, - { { "argumentList", argumentList }, - { "argumentTemplates", argumentTemplates }, - { "chainTemplates", chainTemplates }, - { "commandName", commandName }, - { "const", commandData.handle.empty() ? "" : " const" }, - { "nodiscard", nodiscard }, - { "noexcept", noexceptString }, - { "returnType", returnType } } ); - } -} - std::string VulkanHppGenerator::generateCommandResultEnumerate( std::string const & name, CommandData const & commandData, size_t initialSkipCount, @@ -3754,7 +3617,7 @@ std::string VulkanHppGenerator::generateCommandResultGetVector( std::string cons std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags ); std::string nodiscard = generateNoDiscard( true, 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); std::string dataType = stripPrefix( commandData.params[*templatedParams.begin()].name, "p" ) + "Type"; - std::string returnType = generateReturnType( commandData.successCodes, "std::vector<" + dataType + ",Allocator>" ); + std::string returnType = generateReturnType( commandData, { returnParam }, false, "std::vector<" + dataType + ", Allocator>" ); if ( definition ) { @@ -3817,7 +3680,7 @@ std::string VulkanHppGenerator::generateCommandResultGetVectorAndValue( std::str std::string argumentList = generateArgumentListEnhanced( commandData.params, skippedParams, {}, {}, definition, withAllocator, false, true ); std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags ); std::string nodiscard = generateNoDiscard( !returnParams.empty(), 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); - std::string returnType = generateReturnType( commandData.successCodes, "std::vector" ); + std::string returnType = generateReturnType( commandData, returnParams, false, "std::vector" ); std::string vectorElementType = stripPostfix( commandData.params[returnParams[0]].type.compose( "VULKAN_HPP_NAMESPACE" ), " *" ); std::string allocatorType = startUpperCase( vectorElementType ) + "Allocator"; std::string valueType = stripPostfix( commandData.params[returnParams[1]].type.compose( "VULKAN_HPP_NAMESPACE" ), " *" ); @@ -3895,7 +3758,7 @@ std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesOrValues( assert( beginsWith( commandData.params[returnParam].type.type, "Vk" ) ); std::string elementType = stripPrefix( commandData.params[returnParam].type.type, "Vk" ); std::string returnType = - generateReturnType( commandData.successCodes, "std::vector" ); + generateReturnType( commandData, { returnParam }, false, "std::vector" ); if ( definition ) { @@ -3965,7 +3828,7 @@ std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesUnique( s 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.successCodes, "std::vector, " + handleType + "Allocator>" ); + generateReturnType( commandData, { returnParam }, false, "std::vector, " + handleType + "Allocator>" ); if ( definition ) { @@ -4072,7 +3935,7 @@ std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesUniqueSin std::string commandName = stripPluralS( generateCommandName( name, commandData.params, initialSkipCount, m_tags ) ); 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.successCodes, "UniqueHandle<" + handleType + ", Dispatch>" ); + std::string returnType = generateReturnType( commandData, { returnParam }, false, "UniqueHandle<" + handleType + ", Dispatch>" ); if ( definition ) { @@ -4142,7 +4005,7 @@ std::string VulkanHppGenerator::generateCommandResultMultiSuccessNoErrors0Return if ( constPointerParams.empty() ) { return generateCommandSetStandardOrEnhanced( generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandResult( name, commandData, initialSkipCount, definition, {}, {}, false ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, {}, {}, false, false ) ); } } return ""; @@ -4211,7 +4074,7 @@ std::string VulkanHppGenerator::generateCommandResultMultiSuccessWithErrors1Retu definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandResultGetVector( name, commandData, initialSkipCount, definition, vectorParams, returnParam ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true, false ) ); } } } @@ -4234,7 +4097,7 @@ std::string VulkanHppGenerator::generateCommandResultMultiSuccessWithErrors1Retu generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ), generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true ), + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true, false ), generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ), generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ), generateCommandResultGetVectorOfHandlesUniqueSingular( name, commandData, initialSkipCount, definition, vectorParams, returnParam ) ); @@ -4252,7 +4115,7 @@ std::string VulkanHppGenerator::generateCommandResultMultiSuccessWithErrors1Retu return generateCommandSetStandardEnhanced( definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false, false ) ); } } return ""; @@ -4316,7 +4179,7 @@ std::string VulkanHppGenerator::generateCommandResultMultiSuccessWithErrors2Retu return generateCommandSetStandardEnhanced( definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, returnParams, false ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, returnParams, false, false ) ); } } } @@ -4377,7 +4240,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessNoErrors( std: if ( constPointerParams.empty() ) { return generateCommandSetStandardOrEnhanced( generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandResult( name, commandData, initialSkipCount, definition, {}, {}, false ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, {}, {}, false, false ) ); } } else if ( vectorParams.size() == 1 ) @@ -4388,7 +4251,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessNoErrors( std: { return generateCommandSetStandardEnhanced( definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, {}, false ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, {}, false, false ) ); } } } @@ -4441,7 +4304,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret return generateCommandSetStandardEnhancedChained( definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false ), + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false, false ), generateCommandResultGetChain( name, commandData, initialSkipCount, definition, returnParam ) ); } return ""; @@ -4457,7 +4320,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret return generateCommandSetStandardEnhancedUnique( definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false ), + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false, false ), generateCommandResultGetHandleUnique( name, commandData, initialSkipCount, definition, returnParam ) ); break; case 1: @@ -4514,7 +4377,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ), generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true ), + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true, false ), generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ), generateCommandResultGetVectorOfHandlesUnique( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ), generateCommandResultGetVectorOfHandlesUniqueSingular( name, commandData, initialSkipCount, definition, vectorParams, returnParam ) ); @@ -4535,7 +4398,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret return generateCommandSetStandardEnhanced( definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false, false ) ); case 2: return generateCommandResultSingleSuccessWithErrors1ReturnValue2Vectors( name, commandData, initialSkipCount, definition, returnParam, vectorParams ); break; @@ -4565,7 +4428,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ), generateCommandResultGetVectorOfHandlesOrValues( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true, false ) ); } } } @@ -4583,7 +4446,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret return generateCommandSetStandardEnhanced( definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false, false ) ); break; case 1: if ( returnParam == vectorParams.begin()->first ) @@ -4594,7 +4457,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandResultGetVector( name, commandData, initialSkipCount, definition, vectorParams, returnParam ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true, false ) ); } } break; @@ -4613,7 +4476,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandResultGetVector( name, commandData, initialSkipCount, definition, vectorParams, returnParam ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, true, false ) ); } } } @@ -4675,13 +4538,13 @@ std::string VulkanHppGenerator::generateCommandResultWithErrors0Return( std::str if ( vectorParams.empty() && determineConstPointerParams( commandData.params ).empty() ) { return generateCommandSetStandardOrEnhanced( generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, {}, false ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, {}, false, false ) ); } else if ( allVectorSizesSupported( commandData.params, vectorParams ) ) { return generateCommandSetStandardEnhanced( definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandResult( name, commandData, initialSkipCount, definition, vectorParams, {}, false ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, {}, false, false ) ); } return ""; } @@ -4921,86 +4784,63 @@ std::string VulkanHppGenerator::generateCommandSingle( std::string const & bool definition, std::map const & vectorParams, std::vector const & returnParams, + bool singular, bool chained ) const { - assert( returnParams.size() <= 1 ); - assert( returnParams.empty() || ( vectorParams.find( returnParams[0] ) == vectorParams.end() ) ); + assert( returnParams.size() <= 2 ); assert( vectorParams.empty() || ( vectorParams.begin()->second != INVALID_INDEX ) ); - assert( !chained || !returnParams.empty() ); + assert( !singular || ( returnParams.size() == 1 ) ); // if singular is true, then there is one returnParam ! + assert( !chained || ( returnParams.size() == 1 ) ); // if chained is true, then there is one returnParam ! + assert( !chained || isStructureChainAnchor( commandData.params[returnParams[0]].type.type ) ); - std::set skippedParams = determineSkippedParams( commandData.params, initialSkipCount, vectorParams, returnParams, false ); - std::set templatedParams = determineVoidPointerParams( commandData.params ); - std::string argumentList = generateArgumentListEnhanced( commandData.params, skippedParams, {}, templatedParams, definition, false, false, true ); - std::string argumentTemplates = generateArgumentTemplates( commandData.params, templatedParams, false ); - std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags ); - std::string nodiscard = generateNoDiscard( !returnParams.empty(), 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); - std::pair>> vectorSizeCheck = needsVectorSizeCheck( commandData.params, vectorParams, {} ); - std::string noexceptString = vectorSizeCheck.first ? " VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS" : " VULKAN_HPP_NOEXCEPT"; + std::set skippedParams = determineSkippedParams( commandData.params, initialSkipCount, vectorParams, returnParams, singular ); + // special handling for vkGetMemoryHostPointerPropertiesEXT: here, we really need to stick with the const void * parameter ! + std::set templatedParams = ( name == "vkGetMemoryHostPointerPropertiesEXT" ) ? std::set() : determineVoidPointerParams( commandData.params ); + std::set singularParams = singular ? determineSingularParams( returnParams[0], vectorParams ) : std::set(); + std::pair>> vectorSizeCheck = needsVectorSizeCheck( commandData.params, vectorParams, singularParams ); - std::string chainTemplates, returnType; - if ( returnParams.empty() ) + std::vector dataTypes; + for ( auto rp : returnParams ) { - returnType = stripPrefix( commandData.returnType, "Vk" ); + dataTypes.push_back( ( templatedParams.find( rp ) != templatedParams.end() ) + ? ( stripPrefix( commandData.params[rp].name, "p" ) + "Type" ) + : stripPostfix( commandData.params[rp].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ) ); } - else + std::string dataType; + switch ( dataTypes.size() ) { - if ( chained ) - { - assert( isStructureChainAnchor( commandData.params[returnParams[0]].type.type ) ); - chainTemplates = "typename X, typename Y, typename... Z, "; - returnType = "StructureChain"; - } - else - { - returnType = stripPostfix( commandData.params[returnParams[0]].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ); - } + case 0: dataType = "void"; break; + case 1: dataType = dataTypes[0]; break; + case 2: dataType = "std::pair<" + dataTypes[0] + ", " + dataTypes[1] + ">"; break; + default: assert( false ); break; } + std::string argumentTemplates = generateArgumentTemplates( commandData.params, templatedParams, false ); + std::string chainTemplates = chained ? "typename X, typename Y, typename... Z, " : ""; + std::string nodiscard = generateNoDiscard( !returnParams.empty(), 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); + std::string returnType = generateReturnType( commandData, returnParams, 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 ); + if ( singular ) + { + commandName = stripPluralS( commandName ); + } + std::string argumentList = generateArgumentListEnhanced( commandData.params, skippedParams, singularParams, templatedParams, definition, false, false, true ); + std::string constString = commandData.handle.empty() ? "" : " const"; + std::string noexceptString = + commandData.errorCodes.empty() ? ( vectorSizeCheck.first ? " VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS" : " VULKAN_HPP_NOEXCEPT" ) : ""; + if ( definition ) { - std::string dataDeclarations, returnStatement; - if ( returnParams.empty() ) - { - if ( commandData.returnType != "void" ) - { - returnStatement = "result"; - if ( beginsWith( commandData.returnType, "Vk" ) ) - { - returnStatement = "static_cast<" + returnType + ">( " + returnStatement + " )"; - } - returnStatement = "return " + returnStatement + ";"; - } - } - else - { - std::string returnVariable; - if ( chained ) - { - std::string dataDeclarationsTemplate = R"(${returnType} ${returnVariable}; - ${dataType} & ${dataVariable} = ${returnVariable}.template get<${dataType}>();)"; - - returnVariable = "structureChain"; - dataDeclarations = replaceWithMap( dataDeclarationsTemplate, - { { "dataType", stripPostfix( commandData.params[returnParams[0]].type.compose( "VULKAN_HPP_NAMESPACE" ), " *" ) }, - { "dataVariable", startLowerCase( stripPrefix( commandData.params[returnParams[0]].name, "p" ) ) }, - { "returnType", returnType }, - { "returnVariable", returnVariable } } ); - } - else - { - std::string dataDeclarationsTemplate = R"(${returnType} ${returnVariable};)"; - - returnVariable = startLowerCase( stripPrefix( commandData.params[returnParams[0]].name, "p" ) ); - dataDeclarations = replaceWithMap( dataDeclarationsTemplate, { { "returnType", returnType }, { "returnVariable", returnVariable } } ); - } - returnStatement = "return " + returnVariable + ";"; - } - - std::string resultAssignment; - if ( commandData.returnType != "void" ) - { - resultAssignment = commandData.returnType + " result = "; - } + std::string vectorSizeCheckString = + vectorSizeCheck.first ? generateVectorSizeCheck( name, commandData, initialSkipCount, vectorSizeCheck.second, skippedParams, false ) : ""; + std::string returnVariable = generateReturnVariable( commandData, returnParams, chained, singular ); + std::string dataDeclarations = generateDataDeclarations( commandData, returnParams, chained, dataTypes, returnType, returnVariable ); + std::string resultAssignment = generateResultAssignment( commandData ); + std::string callArguments = generateCallArgumentsEnhanced( commandData, initialSkipCount, false, singularParams, templatedParams, false ); + std::string resultCheck = generateResultCheck( commandData, className, classSeparator, commandName ); + std::string returnStatement = generateReturnStatement( commandData, returnVariable, dataType ); std::string const functionTemplate = R"( template <${argumentTemplates}${chainTemplates}typename Dispatch> @@ -5010,28 +4850,28 @@ std::string VulkanHppGenerator::generateCommandSingle( std::string const & ${vectorSizeCheck} ${dataDeclarations} ${resultAssignment}d.${vkCommand}( ${callArguments} ); + ${resultCheck} ${returnStatement} })"; - return replaceWithMap( - functionTemplate, - { { "argumentList", argumentList }, - { "argumentTemplates", argumentTemplates }, - { "callArguments", generateCallArgumentsEnhanced( commandData, initialSkipCount, false, {}, templatedParams, false ) }, - { "chainTemplates", chainTemplates }, - { "className", initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, - { "classSeparator", commandData.handle.empty() ? "" : "::" }, - { "commandName", commandName }, - { "const", commandData.handle.empty() ? "" : " const" }, - { "dataDeclarations", dataDeclarations }, - { "nodiscard", nodiscard }, - { "noexcept", noexceptString }, - { "resultAssignment", resultAssignment }, - { "returnStatement", returnStatement }, - { "returnType", returnType }, - { "vectorSizeCheck", - vectorSizeCheck.first ? generateVectorSizeCheck( name, commandData, initialSkipCount, vectorSizeCheck.second, skippedParams, false ) : "" }, - { "vkCommand", name } } ); + return replaceWithMap( functionTemplate, + { { "argumentList", argumentList }, + { "argumentTemplates", argumentTemplates }, + { "callArguments", callArguments }, + { "chainTemplates", chainTemplates }, + { "className", className }, + { "classSeparator", classSeparator }, + { "commandName", commandName }, + { "const", constString }, + { "dataDeclarations", dataDeclarations }, + { "nodiscard", nodiscard }, + { "noexcept", noexceptString }, + { "resultAssignment", resultAssignment }, + { "resultCheck", resultCheck }, + { "returnStatement", returnStatement }, + { "returnType", returnType }, + { "vectorSizeCheck", vectorSizeCheckString }, + { "vkCommand", name } } ); } else { @@ -5124,7 +4964,7 @@ std::string return generateCommandSetStandardEnhanced( definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, returnParams, false ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, returnParams, false, false ) ); } } } @@ -5144,7 +4984,7 @@ std::string // All the vectorParams have a counter by value, of type "uint32_t", "VkDeviceSize", or "VkSampleCountFlagBits" (!) return generateCommandSetStandardEnhanced( definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, {}, false ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, {}, false, false ) ); } return ""; } @@ -5160,9 +5000,10 @@ std::string VulkanHppGenerator::generateCommandVoid1Return( std::map vectorParams = determineVectorParams( commandData.params ); if ( vectorParams.empty() ) { - return generateCommandSetStandardEnhanced( definition, - generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandSingle( name, commandData, initialSkipCount, definition, {}, { returnParam }, false ) ); + return generateCommandSetStandardEnhanced( + definition, + generateCommandStandard( name, commandData, initialSkipCount, definition ), + generateCommandSingle( name, commandData, initialSkipCount, definition, {}, { returnParam }, false, false ) ); } } } @@ -5173,7 +5014,7 @@ std::string VulkanHppGenerator::generateCommandVoid1Return( { return generateCommandSetStandardEnhanced( definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandSingle( name, commandData, initialSkipCount, definition, {}, { returnParam }, false ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, {}, { returnParam }, false, false ) ); } } else if ( isStructureChainAnchor( commandData.params[returnParam].type.type ) ) @@ -5181,10 +5022,11 @@ std::string VulkanHppGenerator::generateCommandVoid1Return( std::map vectorParams = determineVectorParams( commandData.params ); if ( vectorParams.empty() ) { - return generateCommandSetStandardEnhancedChained( definition, - generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandSingle( name, commandData, initialSkipCount, definition, {}, { returnParam }, false ), - generateCommandSingle( name, commandData, initialSkipCount, definition, {}, { returnParam }, true ) ); + return generateCommandSetStandardEnhancedChained( + definition, + generateCommandStandard( name, commandData, initialSkipCount, definition ), + generateCommandSingle( name, commandData, initialSkipCount, definition, {}, { returnParam }, false, false ), + generateCommandSingle( name, commandData, initialSkipCount, definition, {}, { returnParam }, false, true ) ); } } else if ( commandData.params[returnParam].type.type != "void" ) @@ -5193,9 +5035,10 @@ std::string VulkanHppGenerator::generateCommandVoid1Return( switch ( vectorParams.size() ) { case 0: - return generateCommandSetStandardEnhanced( definition, - generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandSingle( name, commandData, initialSkipCount, definition, {}, { returnParam }, false ) ); + return generateCommandSetStandardEnhanced( + definition, + generateCommandStandard( name, commandData, initialSkipCount, definition ), + generateCommandSingle( name, commandData, initialSkipCount, definition, {}, { returnParam }, false, false ) ); break; case 1: if ( returnParam != vectorParams.begin()->first ) @@ -5209,7 +5052,7 @@ std::string VulkanHppGenerator::generateCommandVoid1Return( return generateCommandSetStandardEnhanced( definition, generateCommandStandard( name, commandData, initialSkipCount, definition ), - generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false ) ); + generateCommandSingle( name, commandData, initialSkipCount, definition, vectorParams, { returnParam }, false, false ) ); } } } @@ -5426,6 +5269,50 @@ std::string VulkanHppGenerator::generateConstexprString( std::string const & str return isConstExpression ? ( std::string( "VULKAN_HPP_CONSTEXPR" ) + ( ( containsUnion( structName ) || containsArray( structName ) ) ? "_14 " : " " ) ) : ""; } +std::string VulkanHppGenerator::generateDataDeclarations( CommandData const & commandData, + std::vector const & returnParams, + bool chained, + std::vector const & dataTypes, + std::string const & returnType, + std::string const & returnVariable ) const +{ + std::string dataDeclarations; + switch ( returnParams.size() ) + { + case 1: + if ( chained ) + { + assert( commandData.returnType == "void" ); + std::string const dataDeclarationsTemplate = R"(${returnType} ${returnVariable}; + ${dataType} & ${dataVariable} = ${returnVariable}.template get<${dataType}>();)"; + + dataDeclarations = replaceWithMap( dataDeclarationsTemplate, + { { "dataType", dataTypes[0] }, + { "dataVariable", startLowerCase( stripPrefix( commandData.params[returnParams[0]].name, "p" ) ) }, + { "returnType", returnType }, + { "returnVariable", returnVariable } } ); + } + else + { + std::string const dataDeclarationsTemplate = R"(${dataType} ${dataVariable};)"; + dataDeclarations = replaceWithMap( dataDeclarationsTemplate, { { "dataType", dataTypes[0] }, { "dataVariable", returnVariable } } ); + } + break; + case 2: + std::string const dataDeclarationTemplate = R"(std::pair<${firstDataType},${secondDataType}> data; + ${firstDataType} & ${firstDataName} = data.first; + ${secondDataType} & ${secondDataName} = data.second;)"; + + dataDeclarations = replaceWithMap( dataDeclarationTemplate, + { { "firstDataName", startLowerCase( stripPrefix( commandData.params[returnParams[0]].name, "p" ) ) }, + { "firstDataType", dataTypes[0] }, + { "secondDataName", startLowerCase( stripPrefix( commandData.params[returnParams[1]].name, "p" ) ) }, + { "secondDataType", dataTypes[1] } } ); + break; + } + return dataDeclarations; +} + std::string VulkanHppGenerator::generateDestroyCommand( std::string const & name, CommandData const & commandData ) const { // special handling for destroy functions, filter out alias functions @@ -10162,6 +10049,160 @@ std::string VulkanHppGenerator::generateRAIIHandleVectorSizeCheck( std::string c return sizeChecks; } +std::string VulkanHppGenerator::generateResultAssignment( CommandData const & commandData ) const +{ + std::string resultAssignment; + if ( ( commandData.returnType != "void" ) && + !( ( commandData.returnType == "VkResult" ) && ( commandData.successCodes.size() == 1 ) && commandData.errorCodes.empty() ) ) + { + resultAssignment = commandData.returnType + " result = "; + } + return resultAssignment; +} + +std::string VulkanHppGenerator::generateResultCheck( CommandData const & commandData, + std::string const & className, + std::string const & classSeparator, + std::string commandName ) const +{ + std::string resultCheck; + if ( !commandData.errorCodes.empty() ) + { + std::string successCodeList = generateSuccessCodeList( commandData.successCodes ); + + std::string const resultCheckTemplate = + R"(resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} );)"; + + resultCheck = replaceWithMap( + resultCheckTemplate, + { { "className", className }, { "classSeparator", classSeparator }, { "commandName", commandName }, { "successCodeList", successCodeList } } ); + } + return resultCheck; +} + +std::string + VulkanHppGenerator::generateReturnStatement( CommandData const & commandData, std::string const & returnVariable, std::string const & dataType ) const +{ + std::string returnStatement; + if ( beginsWith( commandData.returnType, "Vk" ) ) + { + if ( commandData.successCodes.size() == 1 ) + { + if ( !commandData.errorCodes.empty() ) + { + if ( returnVariable.empty() ) + { + returnStatement = "return createResultValueType( static_cast( result ) );"; + } + else + { + returnStatement = "return createResultValueType( static_cast( result ), " + returnVariable + " );"; + } + } + } + else + { + if ( returnVariable.empty() ) + { + returnStatement = "return static_cast( result );"; + } + else + { + returnStatement = "return ResultValue<" + dataType + ">( static_cast( result ), " + returnVariable + " );"; + } + } + } + else + { + if ( returnVariable.empty() ) + { + if ( commandData.returnType != "void" ) + { + returnStatement = "return result;"; + } + } + else + { + returnStatement = "return " + returnVariable + ";"; + } + } + return returnStatement; +} + +std::string VulkanHppGenerator::generateReturnType( CommandData const & commandData, + std::vector const & returnParams, + bool chained, + std::string const & dataType ) const +{ + std::string returnType; + if ( chained ) + { + assert( ( commandData.returnType == "void" ) && ( returnParams.size() == 1 ) ); + assert( isStructureChainAnchor( commandData.params[returnParams[0]].type.type ) ); + returnType = "StructureChain"; + } + else if ( commandData.returnType == "VkResult" ) + { + if ( commandData.successCodes.size() == 1 ) + { + if ( commandData.errorCodes.empty() ) + { + returnType = dataType; + } + else + { + returnType = "typename ResultValueType<" + dataType + ">::type"; + } + } + else if ( dataType == "void" ) + { + returnType = "VULKAN_HPP_NAMESPACE::Result"; + } + else + { + returnType = "ResultValue<" + dataType + ">"; + } + } + else if ( returnParams.empty() ) + { + if ( beginsWith( commandData.returnType, "Vk" ) ) + { + returnType = "VULKAN_HPP_NAMESPACE::" + stripPrefix( commandData.returnType, "Vk" ); + } + else + { + returnType = commandData.returnType; + } + } + else + { + returnType = dataType; + } + return returnType; +} + +std::string + VulkanHppGenerator::generateReturnVariable( CommandData const & commandData, std::vector const & returnParams, bool chained, bool singular ) const +{ + std::string returnVariable; + if ( returnParams.size() == 1 ) + { + if ( chained ) + { + returnVariable = "structureChain"; + } + else + { + returnVariable = startLowerCase( stripPrefix( commandData.params[returnParams[0]].name, "p" ) ); + if ( singular ) + { + returnVariable = stripPluralS( returnVariable ); + } + } + } + return returnVariable; +} + std::string VulkanHppGenerator::generateSizeCheck( std::vector::const_iterator> const & arrayIts, std::string const & structName, bool mutualExclusiveLens ) const @@ -14372,12 +14413,6 @@ std::string generateNoDiscard( bool returnsSomething, bool multiSuccessCodes, bo return ( returnsSomething || multiSuccessCodes ) ? "VULKAN_HPP_NODISCARD " : ( multiErrorCodes ? "VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS " : "" ); } -std::string generateReturnType( std::vector const & successCodes, std::string const & baseType ) -{ - return ( 1 < successCodes.size() ) ? ( ( baseType == "void" ) ? "Result" : ( "ResultValue<" + baseType + ">" ) ) - : ( "typename ResultValueType<" + baseType + ">::type" ); -} - std::string generateStandardArray( std::string const & type, std::vector const & sizes ) { std::string arrayString = "std::array<" + type + "," + sizes.back() + ">"; @@ -16580,20 +16615,6 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h #endif }; - VULKAN_HPP_INLINE ResultValueType::type createResultValue( Result result, char const * message ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - ignore(message); - VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess ); - return result; -#else - if ( result != Result::eSuccess ) - { - throwResultException( result, message ); - } -#endif - } - template VULKAN_HPP_INLINE typename ResultValueType::type createResultValue( Result result, T & data, char const * message ) { @@ -16610,21 +16631,6 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h #endif } - VULKAN_HPP_INLINE Result createResultValue( Result result, 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 result; - } - template VULKAN_HPP_INLINE ResultValue createResultValue( Result result, T & data, char const * message, std::initializer_list successCodes ) { @@ -16658,27 +16664,6 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h #endif } - template - VULKAN_HPP_INLINE ResultValue> - createResultValue( Result result, - T & data, - char const * message, - std::initializer_list successCodes, - typename UniqueHandleTraits::deleter const & deleter ) - { -# 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>( result, UniqueHandle( data, deleter ) ); - } - template VULKAN_HPP_INLINE typename ResultValueType>>::type createResultValue( Result result, std::vector> && data, char const * message ) @@ -16716,6 +16701,58 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h return ResultValue>>( result, std::move( data ) ); } #endif + + template + VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result, T & data ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + return ResultValue( result, std::move( data ) ); +#else + ignore( result ); + return std::move( data ); +#endif + } + + VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + return result; +#else + ignore( result ); +#endif + } + +)"; + + static const std::string resultChecks = R"( + VULKAN_HPP_INLINE void resultCheck( Result result, char const * message ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty + ignore( message ); + VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess ); +#else + if ( result != Result::eSuccess ) + { + throwResultException( result, message ); + } +#endif + } + + VULKAN_HPP_INLINE void resultCheck( Result result, char const * message, std::initializer_list successCodes ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty + 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 + } )"; static const std::string typeTraits = R"( @@ -16889,7 +16926,7 @@ namespace VULKAN_HPP_NAMESPACE str += exceptions; str += generator.generateResultExceptions(); str += generator.generateThrowResultException(); - str += "#endif\n" + structResultValue; + str += "#endif\n" + structResultValue + resultChecks; str += R"(} // namespace VULKAN_HPP_NAMESPACE // clang-format off diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index f07783c..996324f 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -458,13 +458,6 @@ private: std::vector const & params, size_t initialSkipCount, std::set const & tags ) const; - std::string generateCommandResult( std::string const & name, - CommandData const & commandData, - size_t initialSkipCount, - bool definition, - std::map const & vectorParamIndices, - std::vector const & returnParams, - bool singular ) const; std::string generateCommandResultEnumerate( std::string const & name, CommandData const & commandData, size_t initialSkipCount, @@ -629,6 +622,7 @@ private: bool definition, std::map const & vectorParamIndices, std::vector const & returnParams, + bool singular, bool chained ) const; std::string generateCommandStandard( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const; std::string generateCommandValue( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const; @@ -652,6 +646,12 @@ private: std::vector const & returnParamIndices, bool withAllocators ) const; std::string generateConstexprString( std::string const & structName ) const; + std::string generateDataDeclarations( CommandData const & commandData, + std::vector const & returnParams, + bool chained, + std::vector const & dataTypes, + std::string const & returnType, + std::string const & returnVariable ) const; std::string generateDestroyCommand( std::string const & name, CommandData const & commandData ) const; std::string generateDispatchLoaderDynamicCommandAssignment( std::string const & commandName, CommandData const & commandData, std::string const & firstArg ) const; @@ -942,6 +942,12 @@ private: size_t initialSkipCount, std::map> const & countToVectorMap, std::set const & skippedParams ) const; + std::string generateResultAssignment( CommandData const & commandData ) const; + std::string + generateResultCheck( CommandData const & commandData, std::string const & className, std::string const & classSeparator, std::string commandName ) const; + std::string generateReturnStatement( CommandData const & commandData, std::string const & returnVariable, std::string const & dataType ) const; + std::string generateReturnType( CommandData const & commandData, std::vector const & returnParams, bool chained, std::string const & dataType ) const; + std::string generateReturnVariable( CommandData const & commandData, std::vector const & returnParams, bool chained, bool singular ) const; std::string generateSizeCheck( std::vector::const_iterator> const & arrayIts, std::string const & structName, bool mutualExclusiveLens ) const; std::string generateStruct( std::pair const & structure, std::set & listedStructs ) const; diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 364a73f..68191b4 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -5967,20 +5967,6 @@ namespace VULKAN_HPP_NAMESPACE #endif }; - VULKAN_HPP_INLINE ResultValueType::type createResultValue( Result result, char const * message ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - ignore( message ); - VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess ); - return result; -#else - if ( result != Result::eSuccess ) - { - throwResultException( result, message ); - } -#endif - } - template VULKAN_HPP_INLINE typename ResultValueType::type createResultValue( Result result, T & data, char const * message ) { @@ -5997,21 +5983,6 @@ namespace VULKAN_HPP_NAMESPACE #endif } - VULKAN_HPP_INLINE Result createResultValue( Result result, 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 result; - } - template VULKAN_HPP_INLINE ResultValue createResultValue( Result result, T & data, char const * message, std::initializer_list successCodes ) { @@ -6046,23 +6017,6 @@ namespace VULKAN_HPP_NAMESPACE # endif } - template - VULKAN_HPP_INLINE ResultValue> createResultValue( - Result result, T & data, char const * message, std::initializer_list successCodes, typename UniqueHandleTraits::deleter const & deleter ) - { -# 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>( result, UniqueHandle( data, deleter ) ); - } - template VULKAN_HPP_INLINE typename ResultValueType>>::type createResultValue( Result result, std::vector> && data, char const * message ) @@ -6097,6 +6051,55 @@ namespace VULKAN_HPP_NAMESPACE return ResultValue>>( result, std::move( data ) ); } #endif + + template + VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result, T & data ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + return ResultValue( result, std::move( data ) ); +#else + ignore( result ); + return std::move( data ); +#endif + } + + VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + return result; +#else + ignore( result ); +#endif + } + + VULKAN_HPP_INLINE void resultCheck( Result result, char const * message ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty + ignore( message ); + VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess ); +#else + if ( result != Result::eSuccess ) + { + throwResultException( result, message ); + } +#endif + } + + VULKAN_HPP_INLINE void resultCheck( Result result, char const * message, std::initializer_list successCodes ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty + 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 + } } // namespace VULKAN_HPP_NAMESPACE // clang-format off diff --git a/vulkan/vulkan_funcs.hpp b/vulkan/vulkan_funcs.hpp index 3961945..f5f2eb7 100644 --- a/vulkan/vulkan_funcs.hpp +++ b/vulkan/vulkan_funcs.hpp @@ -36,11 +36,12 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Instance instance; - Result result = static_cast( + VkResult result = d.vkCreateInstance( reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &instance ) ) ); - return createResultValue( result, instance, VULKAN_HPP_NAMESPACE_STRING "::createInstance" ); + reinterpret_cast( &instance ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::createInstance" ); + return createResultValueType( static_cast( result ), instance ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -166,6 +167,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features; d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast( &features ) ); + return features; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -188,6 +190,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::FormatProperties formatProperties; d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + return formatProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -224,14 +227,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties; - Result result = static_cast( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, - static_cast( format ), - static_cast( type ), - static_cast( tiling ), - static_cast( usage ), - static_cast( flags ), - reinterpret_cast( &imageFormatProperties ) ) ); - return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" ); + VkResult result = d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, + static_cast( format ), + static_cast( type ), + static_cast( tiling ), + static_cast( usage ), + 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*/ @@ -252,6 +256,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties; d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast( &properties ) ); + return properties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -318,6 +323,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties; d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + return memoryProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -336,6 +342,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); PFN_vkVoidFunction result = d.vkGetInstanceProcAddr( m_instance, name.c_str() ); + return result; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -354,6 +361,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); PFN_vkVoidFunction result = d.vkGetDeviceProcAddr( m_device, name.c_str() ); + return result; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -379,12 +387,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Device device; - Result result = static_cast( + VkResult result = d.vkCreateDevice( m_physicalDevice, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &device ) ) ); - return createResultValue( result, device, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDevice" ); + reinterpret_cast( &device ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDevice" ); + return createResultValueType( static_cast( result ), device ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -739,6 +748,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Queue queue; d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast( &queue ) ); + return queue; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -760,9 +770,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkQueueSubmit( m_queue, submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" ); + 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*/ @@ -779,8 +789,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkQueueWaitIdle( m_queue ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" ); + 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*/ @@ -797,8 +808,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkDeviceWaitIdle( m_device ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" ); + 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*/ @@ -825,12 +837,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DeviceMemory memory; - Result result = static_cast( + VkResult result = d.vkAllocateMemory( m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &memory ) ) ); - return createResultValue( result, memory, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemory" ); + reinterpret_cast( &memory ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemory" ); + return createResultValueType( static_cast( result ), memory ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -927,14 +940,15 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - void * pData; - Result result = static_cast( d.vkMapMemory( m_device, - static_cast( memory ), - static_cast( offset ), - static_cast( size ), - static_cast( flags ), - &pData ) ); - return createResultValue( result, pData, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory" ); + void * pData; + VkResult result = d.vkMapMemory( m_device, + static_cast( memory ), + static_cast( offset ), + static_cast( size ), + 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*/ @@ -961,9 +975,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = - static_cast( d.vkFlushMappedMemoryRanges( m_device, memoryRanges.size(), reinterpret_cast( memoryRanges.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" ); + 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*/ @@ -984,9 +998,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size(), reinterpret_cast( memoryRanges.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" ); + 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*/ @@ -1008,6 +1022,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes; d.vkGetDeviceMemoryCommitment( m_device, static_cast( memory ), reinterpret_cast( &committedMemoryInBytes ) ); + return committedMemoryInBytes; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1030,9 +1045,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkBindBufferMemory( m_device, static_cast( buffer ), static_cast( memory ), static_cast( memoryOffset ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory" ); + 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*/ @@ -1054,9 +1070,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkBindImageMemory( m_device, static_cast( image ), static_cast( memory ), static_cast( memoryOffset ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory" ); + 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*/ @@ -1078,6 +1095,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements; d.vkGetBufferMemoryRequirements( m_device, static_cast( buffer ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1100,6 +1118,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements; d.vkGetImageMemoryRequirements( m_device, static_cast( image ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -1269,9 +1288,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkQueueBindSparse( m_queue, bindInfo.size(), reinterpret_cast( bindInfo.data() ), static_cast( fence ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" ); + 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*/ @@ -1296,12 +1316,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Fence fence; - Result result = static_cast( + VkResult result = d.vkCreateFence( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &fence ) ) ); - return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::createFence" ); + reinterpret_cast( &fence ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createFence" ); + return createResultValueType( static_cast( result ), fence ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -1384,8 +1405,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkResetFences( m_device, fences.size(), reinterpret_cast( fences.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" ); + 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*/ @@ -1398,13 +1420,15 @@ namespace VULKAN_HPP_NAMESPACE } #else template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkGetFenceStatus( m_device, static_cast( fence ) ) ); - return createResultValue( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceStatus", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); + VkResult result = d.vkGetFenceStatus( m_device, static_cast( fence ) ); + 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*/ @@ -1422,17 +1446,19 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForFences( ArrayProxy const & fences, - VULKAN_HPP_NAMESPACE::Bool32 waitAll, - uint64_t timeout, - Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::waitForFences( ArrayProxy const & fences, + VULKAN_HPP_NAMESPACE::Bool32 waitAll, + uint64_t timeout, + Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkWaitForFences( m_device, fences.size(), reinterpret_cast( fences.data() ), static_cast( waitAll ), timeout ) ); - return createResultValue( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); + VkResult result = + d.vkWaitForFences( m_device, fences.size(), reinterpret_cast( fences.data() ), static_cast( waitAll ), timeout ); + 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*/ @@ -1459,12 +1485,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Semaphore semaphore; - Result result = static_cast( + VkResult result = d.vkCreateSemaphore( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &semaphore ) ) ); - return createResultValue( result, semaphore, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphore" ); + reinterpret_cast( &semaphore ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphore" ); + return createResultValueType( static_cast( result ), semaphore ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -1555,12 +1582,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Event event; - Result result = static_cast( + VkResult result = d.vkCreateEvent( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &event ) ) ); - return createResultValue( result, event, VULKAN_HPP_NAMESPACE_STRING "::Device::createEvent" ); + reinterpret_cast( &event ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createEvent" ); + return createResultValueType( static_cast( result ), event ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -1636,13 +1664,15 @@ namespace VULKAN_HPP_NAMESPACE } #else template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::getEventStatus( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkGetEventStatus( m_device, static_cast( event ) ) ); - return createResultValue( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEventStatus", { VULKAN_HPP_NAMESPACE::Result::eEventSet, VULKAN_HPP_NAMESPACE::Result::eEventReset } ); + VkResult result = d.vkGetEventStatus( m_device, static_cast( event ) ); + 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*/ @@ -1660,8 +1690,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkSetEvent( m_device, static_cast( event ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setEvent" ); + 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*/ @@ -1678,8 +1709,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkResetEvent( m_device, static_cast( event ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetEvent" ); + 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*/ @@ -1706,12 +1738,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::QueryPool queryPool; - Result result = static_cast( + VkResult result = d.vkCreateQueryPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &queryPool ) ) ); - return createResultValue( result, queryPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPool" ); + reinterpret_cast( &queryPool ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPool" ); + return createResultValueType( static_cast( result ), queryPool ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -1841,18 +1874,18 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); DataType data; - Result result = static_cast( d.vkGetQueryPoolResults( m_device, - static_cast( queryPool ), - firstQuery, - queryCount, - sizeof( DataType ), - reinterpret_cast( &data ), - static_cast( stride ), - static_cast( flags ) ) ); - return createResultValue( result, - data, - VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResult", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); + VkResult result = d.vkGetQueryPoolResults( m_device, + static_cast( queryPool ), + firstQuery, + queryCount, + sizeof( DataType ), + reinterpret_cast( &data ), + static_cast( stride ), + static_cast( flags ) ); + 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*/ @@ -1877,12 +1910,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Buffer buffer; - Result result = static_cast( + VkResult result = d.vkCreateBuffer( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &buffer ) ) ); - return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createBuffer" ); + reinterpret_cast( &buffer ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createBuffer" ); + return createResultValueType( static_cast( result ), buffer ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -1972,12 +2006,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::BufferView view; - Result result = static_cast( + VkResult result = d.vkCreateBufferView( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &view ) ) ); - return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferView" ); + reinterpret_cast( &view ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferView" ); + return createResultValueType( static_cast( result ), view ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -2068,12 +2103,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Image image; - Result result = static_cast( + VkResult result = d.vkCreateImage( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &image ) ) ); - return createResultValue( result, image, VULKAN_HPP_NAMESPACE_STRING "::Device::createImage" ); + reinterpret_cast( &image ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createImage" ); + return createResultValueType( static_cast( result ), image ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -2165,6 +2201,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( image ), reinterpret_cast( &subresource ), reinterpret_cast( &layout ) ); + return layout; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -2192,12 +2229,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::ImageView view; - Result result = static_cast( + VkResult result = d.vkCreateImageView( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &view ) ) ); - return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageView" ); + reinterpret_cast( &view ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createImageView" ); + return createResultValueType( static_cast( result ), view ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -2289,12 +2327,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::ShaderModule shaderModule; - Result result = static_cast( + VkResult result = d.vkCreateShaderModule( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &shaderModule ) ) ); - return createResultValue( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModule" ); + reinterpret_cast( &shaderModule ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModule" ); + return createResultValueType( static_cast( result ), shaderModule ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -2387,12 +2426,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache; - Result result = static_cast( + VkResult result = d.vkCreatePipelineCache( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &pipelineCache ) ) ); - return createResultValue( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCache" ); + reinterpret_cast( &pipelineCache ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCache" ); + return createResultValueType( static_cast( result ), pipelineCache ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -2550,9 +2590,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkMergePipelineCaches( - m_device, static_cast( dstCache ), srcCaches.size(), reinterpret_cast( srcCaches.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergePipelineCaches" ); + 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*/ @@ -2632,17 +2673,17 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Pipeline pipeline; - Result result = static_cast( d.vkCreateGraphicsPipelines( + VkResult result = d.vkCreateGraphicsPipelines( m_device, static_cast( pipelineCache ), 1, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &pipeline ) ) ); - return createResultValue( result, - pipeline, - VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipeline", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + reinterpret_cast( &pipeline ) ); + 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 @@ -2816,17 +2857,17 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Pipeline pipeline; - Result result = static_cast( d.vkCreateComputePipelines( + VkResult result = d.vkCreateComputePipelines( m_device, static_cast( pipelineCache ), 1, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &pipeline ) ) ); - return createResultValue( result, - pipeline, - VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipeline", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + reinterpret_cast( &pipeline ) ); + 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 @@ -2993,12 +3034,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout; - Result result = static_cast( + VkResult result = d.vkCreatePipelineLayout( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &pipelineLayout ) ) ); - return createResultValue( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayout" ); + reinterpret_cast( &pipelineLayout ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayout" ); + return createResultValueType( static_cast( result ), pipelineLayout ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -3089,12 +3131,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Sampler sampler; - Result result = static_cast( + VkResult result = d.vkCreateSampler( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &sampler ) ) ); - return createResultValue( result, sampler, VULKAN_HPP_NAMESPACE_STRING "::Device::createSampler" ); + reinterpret_cast( &sampler ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSampler" ); + return createResultValueType( static_cast( result ), sampler ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -3184,12 +3227,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout; - Result result = static_cast( d.vkCreateDescriptorSetLayout( + VkResult result = d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &setLayout ) ) ); - return createResultValue( result, setLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayout" ); + reinterpret_cast( &setLayout ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayout" ); + return createResultValueType( static_cast( result ), setLayout ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -3286,12 +3330,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool; - Result result = static_cast( + VkResult result = d.vkCreateDescriptorPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &descriptorPool ) ) ); - return createResultValue( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPool" ); + reinterpret_cast( &descriptorPool ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPool" ); + return createResultValueType( static_cast( result ), descriptorPool ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -3373,15 +3418,13 @@ namespace VULKAN_HPP_NAMESPACE } #else template - VULKAN_HPP_INLINE typename ResultValueType::type Device::resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, - VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE void Device::resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, + VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkResetDescriptorPool( m_device, static_cast( descriptorPool ), static_cast( flags ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetDescriptorPool" ); + d.vkResetDescriptorPool( m_device, static_cast( descriptorPool ), static_cast( flags ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -3486,16 +3529,14 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType::type - Device::freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, - ArrayProxy const & descriptorSets, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE void Device::freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, + ArrayProxy const & descriptorSets, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkFreeDescriptorSets( - m_device, static_cast( descriptorPool ), descriptorSets.size(), reinterpret_cast( descriptorSets.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::freeDescriptorSets" ); + d.vkFreeDescriptorSets( + m_device, static_cast( descriptorPool ), descriptorSets.size(), reinterpret_cast( descriptorSets.data() ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -3512,15 +3553,14 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE typename ResultValueType::type( Device::free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, - ArrayProxy const & descriptorSets, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE void( Device::free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, + ArrayProxy const & descriptorSets, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkFreeDescriptorSets( - m_device, static_cast( descriptorPool ), descriptorSets.size(), reinterpret_cast( descriptorSets.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::( Device::free )" ); + d.vkFreeDescriptorSets( + m_device, static_cast( descriptorPool ), descriptorSets.size(), reinterpret_cast( descriptorSets.data() ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -3578,12 +3618,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Framebuffer framebuffer; - Result result = static_cast( + VkResult result = d.vkCreateFramebuffer( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &framebuffer ) ) ); - return createResultValue( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebuffer" ); + reinterpret_cast( &framebuffer ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebuffer" ); + return createResultValueType( static_cast( result ), framebuffer ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -3676,12 +3717,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::RenderPass renderPass; - Result result = static_cast( + VkResult result = d.vkCreateRenderPass( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &renderPass ) ) ); - return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass" ); + reinterpret_cast( &renderPass ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass" ); + return createResultValueType( static_cast( result ), renderPass ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -3769,6 +3811,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Extent2D granularity; d.vkGetRenderAreaGranularity( m_device, static_cast( renderPass ), reinterpret_cast( &granularity ) ); + return granularity; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -3796,12 +3839,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::CommandPool commandPool; - Result result = static_cast( + VkResult result = d.vkCreateCommandPool( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &commandPool ) ) ); - return createResultValue( result, commandPool, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPool" ); + reinterpret_cast( &commandPool ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPool" ); + return createResultValueType( static_cast( result ), commandPool ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -3887,9 +3931,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = - static_cast( d.vkResetCommandPool( m_device, static_cast( commandPool ), static_cast( flags ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetCommandPool" ); + 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*/ @@ -4044,8 +4088,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast( &beginInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" ); + 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*/ @@ -4062,8 +4107,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkEndCommandBuffer( m_commandBuffer ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" ); + 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*/ @@ -4081,8 +4127,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkResetCommandBuffer( m_commandBuffer, static_cast( flags ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" ); + 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*/ @@ -4993,8 +5040,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); uint32_t apiVersion; - Result result = static_cast( d.vkEnumerateInstanceVersion( &apiVersion ) ); - return createResultValue( result, apiVersion, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceVersion" ); + 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*/ @@ -5014,9 +5062,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = - static_cast( d.vkBindBufferMemory2( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" ); + 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*/ @@ -5036,9 +5084,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = - static_cast( d.vkBindImageMemory2( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" ); + 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*/ @@ -5064,6 +5112,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures; d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( &peerMemoryFeatures ) ); + return peerMemoryFeatures; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5182,6 +5231,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; } @@ -5195,6 +5245,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get(); d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5219,6 +5270,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; } @@ -5232,6 +5284,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get(); d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5308,6 +5361,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features; d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast( &features ) ); + return features; } @@ -5319,6 +5373,7 @@ namespace VULKAN_HPP_NAMESPACE StructureChain structureChain; VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = structureChain.template get(); d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast( &features ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5340,6 +5395,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties; d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast( &properties ) ); + return properties; } @@ -5351,6 +5407,7 @@ namespace VULKAN_HPP_NAMESPACE StructureChain structureChain; VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = structureChain.template get(); d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast( &properties ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5373,6 +5430,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties; d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + return formatProperties; } @@ -5385,6 +5443,7 @@ namespace VULKAN_HPP_NAMESPACE StructureChain structureChain; VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = structureChain.template get(); d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5409,11 +5468,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties; - Result result = - static_cast( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, - reinterpret_cast( &imageFormatInfo ), - reinterpret_cast( &imageFormatProperties ) ) ); - return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); + VkResult result = d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, + reinterpret_cast( &imageFormatInfo ), + reinterpret_cast( &imageFormatProperties ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); + return createResultValueType( static_cast( result ), imageFormatProperties ); } template @@ -5543,6 +5602,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties; d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + return memoryProperties; } @@ -5555,6 +5615,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties = structureChain.template get(); d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5642,6 +5703,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Queue queue; d.vkGetDeviceQueue2( m_device, reinterpret_cast( &queueInfo ), reinterpret_cast( &queue ) ); + return queue; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5670,12 +5732,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; - Result result = static_cast( d.vkCreateSamplerYcbcrConversion( + VkResult result = d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &ycbcrConversion ) ) ); - return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion" ); + reinterpret_cast( &ycbcrConversion ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion" ); + return createResultValueType( static_cast( result ), ycbcrConversion ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -5773,12 +5836,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; - Result result = static_cast( d.vkCreateDescriptorUpdateTemplate( + VkResult result = d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &descriptorUpdateTemplate ) ) ); - return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplate" ); + reinterpret_cast( &descriptorUpdateTemplate ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplate" ); + return createResultValueType( static_cast( result ), descriptorUpdateTemplate ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -5902,6 +5966,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast( &externalBufferInfo ), reinterpret_cast( &externalBufferProperties ) ); + return externalBufferProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5929,6 +5994,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast( &externalFenceInfo ), reinterpret_cast( &externalFenceProperties ) ); + return externalFenceProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5957,6 +6023,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast( &externalSemaphoreInfo ), reinterpret_cast( &externalSemaphoreProperties ) ); + return externalSemaphoreProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -5982,6 +6049,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support; d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); + return support; } @@ -5996,6 +6064,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = structureChain.template get(); d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -6063,12 +6132,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::RenderPass renderPass; - Result result = static_cast( + VkResult result = d.vkCreateRenderPass2( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &renderPass ) ) ); - return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2" ); + reinterpret_cast( &renderPass ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2" ); + return createResultValueType( static_cast( result ), renderPass ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -6182,8 +6252,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); uint64_t value; - Result result = static_cast( d.vkGetSemaphoreCounterValue( m_device, static_cast( semaphore ), &value ) ); - return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValue" ); + 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*/ @@ -6198,15 +6269,16 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, - uint64_t timeout, - Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result + Device::waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkWaitSemaphores( m_device, reinterpret_cast( &waitInfo ), timeout ) ); - return createResultValue( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); + VkResult result = d.vkWaitSemaphores( m_device, reinterpret_cast( &waitInfo ), timeout ); + 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*/ @@ -6225,8 +6297,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkSignalSemaphore( m_device, reinterpret_cast( &signalInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" ); + 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*/ @@ -6240,13 +6313,14 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress Device::getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VkDeviceAddress result = d.vkGetBufferDeviceAddress( m_device, reinterpret_cast( &info ) ); - return static_cast( result ); + + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -6266,6 +6340,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); uint64_t result = d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast( &info ) ); + return result; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -6286,6 +6361,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); uint64_t result = d.vkGetDeviceMemoryOpaqueCaptureAddress( m_device, reinterpret_cast( &info ) ); + return result; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -6388,12 +6464,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; - Result result = static_cast( + VkResult result = d.vkCreatePrivateDataSlot( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &privateDataSlot ) ) ); - return createResultValue( result, privateDataSlot, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlot" ); + reinterpret_cast( &privateDataSlot ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlot" ); + return createResultValueType( static_cast( result ), privateDataSlot ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -6487,9 +6564,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkSetPrivateData( m_device, static_cast( objectType ), objectHandle, static_cast( privateDataSlot ), data ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateData" ); + 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*/ @@ -6515,6 +6593,7 @@ namespace VULKAN_HPP_NAMESPACE uint64_t data; d.vkGetPrivateData( m_device, static_cast( objectType ), objectHandle, static_cast( privateDataSlot ), &data ); + return data; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -6629,9 +6708,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkQueueSubmit2( m_queue, submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2" ); + 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*/ @@ -6986,6 +7065,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; d.vkGetDeviceBufferMemoryRequirements( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; } @@ -6999,6 +7079,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get(); d.vkGetDeviceBufferMemoryRequirements( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -7023,6 +7104,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; d.vkGetDeviceImageMemoryRequirements( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; } @@ -7036,6 +7118,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get(); d.vkGetDeviceImageMemoryRequirements( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -7163,9 +7246,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Bool32 supported; - Result result = static_cast( d.vkGetPhysicalDeviceSurfaceSupportKHR( - m_physicalDevice, queueFamilyIndex, static_cast( surface ), reinterpret_cast( &supported ) ) ); - return createResultValue( result, supported, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" ); + 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*/ @@ -7187,9 +7271,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities; - Result result = static_cast( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( - m_physicalDevice, static_cast( surface ), reinterpret_cast( &surfaceCapabilities ) ) ); - return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" ); + 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*/ @@ -7374,12 +7459,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; - Result result = static_cast( + VkResult result = d.vkCreateSwapchainKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &swapchain ) ) ); - return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHR" ); + reinterpret_cast( &swapchain ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHR" ); + return createResultValueType( static_cast( result ), swapchain ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -7544,15 +7630,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); uint32_t imageIndex; - Result result = static_cast( d.vkAcquireNextImageKHR( - m_device, static_cast( swapchain ), timeout, static_cast( semaphore ), static_cast( fence ), &imageIndex ) ); - return createResultValue( result, - imageIndex, - VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImageKHR", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, - VULKAN_HPP_NAMESPACE::Result::eTimeout, - VULKAN_HPP_NAMESPACE::Result::eNotReady, - VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); + VkResult result = d.vkAcquireNextImageKHR( + m_device, static_cast( swapchain ), timeout, static_cast( semaphore ), static_cast( fence ), &imageIndex ); + resultCheck( static_cast( result ), + VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImageKHR", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, + 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*/ @@ -7566,13 +7652,16 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo, Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Queue::presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo, + Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkQueuePresentKHR( m_queue, reinterpret_cast( &presentInfo ) ) ); - return createResultValue( - result, VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); + VkResult result = d.vkQueuePresentKHR( m_queue, reinterpret_cast( &presentInfo ) ); + 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*/ @@ -7593,9 +7682,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities; - Result result = static_cast( - d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast( &deviceGroupPresentCapabilities ) ) ); - return createResultValue( result, deviceGroupPresentCapabilities, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" ); + 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*/ @@ -7617,9 +7707,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes; - Result result = static_cast( d.vkGetDeviceGroupSurfacePresentModesKHR( - m_device, static_cast( surface ), reinterpret_cast( &modes ) ) ); - return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" ); + 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*/ @@ -7711,15 +7802,14 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); uint32_t imageIndex; - Result result = - static_cast( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast( &acquireInfo ), &imageIndex ) ); - return createResultValue( result, - imageIndex, - VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, - VULKAN_HPP_NAMESPACE::Result::eTimeout, - VULKAN_HPP_NAMESPACE::Result::eNotReady, - VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); + VkResult result = d.vkAcquireNextImage2KHR( m_device, reinterpret_cast( &acquireInfo ), &imageIndex ); + resultCheck( static_cast( result ), + VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, + 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*/ @@ -8047,13 +8137,14 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DisplayModeKHR mode; - Result result = static_cast( + VkResult result = d.vkCreateDisplayModeKHR( m_physicalDevice, static_cast( display ), reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &mode ) ) ); - return createResultValue( result, mode, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHR" ); + reinterpret_cast( &mode ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHR" ); + return createResultValueType( static_cast( result ), mode ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -8099,9 +8190,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities; - Result result = static_cast( d.vkGetDisplayPlaneCapabilitiesKHR( - m_physicalDevice, static_cast( mode ), planeIndex, reinterpret_cast( &capabilities ) ) ); - return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" ); + 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*/ @@ -8128,12 +8220,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( d.vkCreateDisplayPlaneSurfaceKHR( + VkResult result = d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -8222,13 +8315,14 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; - Result result = static_cast( d.vkCreateSharedSwapchainsKHR( + VkResult result = d.vkCreateSharedSwapchainsKHR( m_device, 1, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &swapchain ) ) ); - return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHR" ); + 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 @@ -8336,12 +8430,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( + VkResult result = d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -8375,13 +8470,14 @@ namespace VULKAN_HPP_NAMESPACE # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE Bool32 + VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VkBool32 result = d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID ); - return static_cast( result ); + + return static_cast( result ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_XLIB_KHR*/ @@ -8412,12 +8508,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( + VkResult result = d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -8453,15 +8550,16 @@ namespace VULKAN_HPP_NAMESPACE # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, - xcb_connection_t & connection, - xcb_visualid_t visual_id, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, + xcb_connection_t & connection, + xcb_visualid_t visual_id, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VkBool32 result = d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id ); - return static_cast( result ); + + return static_cast( result ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_XCB_KHR*/ @@ -8492,12 +8590,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( d.vkCreateWaylandSurfaceKHR( + VkResult result = d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -8532,14 +8631,14 @@ namespace VULKAN_HPP_NAMESPACE # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, - struct wl_display & display, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 + PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VkBool32 result = d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display ); - return static_cast( result ); + + return static_cast( result ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ @@ -8570,12 +8669,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( d.vkCreateAndroidSurfaceKHR( + VkResult result = d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -8626,12 +8726,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( + VkResult result = d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -8689,12 +8790,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback; - Result result = static_cast( d.vkCreateDebugReportCallbackEXT( + VkResult result = d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &callback ) ) ); - return createResultValue( result, callback, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT" ); + reinterpret_cast( &callback ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT" ); + return createResultValueType( static_cast( result ), callback ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -8830,8 +8932,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast( &tagInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" ); + 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*/ @@ -8850,8 +8953,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast( &nameInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" ); + 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*/ @@ -8921,9 +9025,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR capabilities; - Result result = static_cast( d.vkGetPhysicalDeviceVideoCapabilitiesKHR( - m_physicalDevice, reinterpret_cast( &videoProfile ), reinterpret_cast( &capabilities ) ) ); - return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); + 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 ); } template @@ -9049,12 +9154,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession; - Result result = static_cast( + VkResult result = d.vkCreateVideoSessionKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &videoSession ) ) ); - return createResultValue( result, videoSession, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHR" ); + reinterpret_cast( &videoSession ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHR" ); + return createResultValueType( static_cast( result ), videoSession ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -9236,11 +9342,12 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkBindVideoSessionMemoryKHR( m_device, - static_cast( videoSession ), - videoSessionBindMemories.size(), - reinterpret_cast( videoSessionBindMemories.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindVideoSessionMemoryKHR" ); + VkResult result = d.vkBindVideoSessionMemoryKHR( m_device, + static_cast( videoSession ), + 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*/ @@ -9268,12 +9375,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters; - Result result = static_cast( d.vkCreateVideoSessionParametersKHR( + VkResult result = d.vkCreateVideoSessionParametersKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &videoSessionParameters ) ) ); - return createResultValue( result, videoSessionParameters, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHR" ); + reinterpret_cast( &videoSessionParameters ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHR" ); + return createResultValueType( static_cast( result ), videoSessionParameters ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -9318,11 +9426,11 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = - static_cast( d.vkUpdateVideoSessionParametersKHR( m_device, - static_cast( videoSessionParameters ), - reinterpret_cast( &updateInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::updateVideoSessionParametersKHR" ); + VkResult result = d.vkUpdateVideoSessionParametersKHR( m_device, + 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*/ @@ -9651,12 +9759,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::CuModuleNVX module; - Result result = static_cast( + VkResult result = d.vkCreateCuModuleNVX( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &module ) ) ); - return createResultValue( result, module, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVX" ); + reinterpret_cast( &module ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVX" ); + return createResultValueType( static_cast( result ), module ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -9703,12 +9812,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::CuFunctionNVX function; - Result result = static_cast( + VkResult result = d.vkCreateCuFunctionNVX( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &function ) ) ); - return createResultValue( result, function, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVX" ); + reinterpret_cast( &function ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVX" ); + return createResultValueType( static_cast( result ), function ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -9861,6 +9971,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); uint32_t result = d.vkGetImageViewHandleNVX( m_device, reinterpret_cast( &info ) ); + return result; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -9883,9 +9994,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties; - Result result = static_cast( - d.vkGetImageViewAddressNVX( m_device, static_cast( imageView ), reinterpret_cast( &properties ) ) ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewAddressNVX" ); + 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*/ @@ -10088,12 +10200,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( d.vkCreateStreamDescriptorSurfaceGGP( + VkResult result = d.vkCreateStreamDescriptorSurfaceGGP( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -10157,7 +10270,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV externalImageFormatProperties; - Result result = static_cast( + VkResult result = d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast( format ), static_cast( type ), @@ -10165,8 +10278,9 @@ namespace VULKAN_HPP_NAMESPACE static_cast( usage ), static_cast( flags ), static_cast( externalHandleType ), - reinterpret_cast( &externalImageFormatProperties ) ) ); - return createResultValue( result, externalImageFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" ); + 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*/ @@ -10191,10 +10305,11 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - HANDLE handle; - Result result = static_cast( - d.vkGetMemoryWin32HandleNV( m_device, static_cast( memory ), static_cast( handleType ), &handle ) ); - return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleNV" ); + HANDLE handle; + 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*/ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -10218,6 +10333,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features; d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast( &features ) ); + return features; } @@ -10229,6 +10345,7 @@ namespace VULKAN_HPP_NAMESPACE StructureChain structureChain; VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = structureChain.template get(); d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast( &features ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -10250,6 +10367,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties; d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast( &properties ) ); + return properties; } @@ -10261,6 +10379,7 @@ namespace VULKAN_HPP_NAMESPACE StructureChain structureChain; VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = structureChain.template get(); d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast( &properties ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -10285,6 +10404,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties; d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + return formatProperties; } @@ -10298,6 +10418,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = structureChain.template get(); d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -10322,11 +10443,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties; - Result result = - static_cast( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, - reinterpret_cast( &imageFormatInfo ), - reinterpret_cast( &imageFormatProperties ) ) ); - return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); + VkResult result = d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, + reinterpret_cast( &imageFormatInfo ), + reinterpret_cast( &imageFormatProperties ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); + return createResultValueType( static_cast( result ), imageFormatProperties ); } template @@ -10456,6 +10577,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties; d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + return memoryProperties; } @@ -10468,6 +10590,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties = structureChain.template get(); d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -10553,6 +10676,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures; d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( &peerMemoryFeatures ) ); + return peerMemoryFeatures; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -10603,12 +10727,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( + VkResult result = d.vkCreateViSurfaceNN( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNN" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNN" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -10745,6 +10870,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast( &externalBufferInfo ), reinterpret_cast( &externalBufferProperties ) ); + return externalBufferProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -10769,10 +10895,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - HANDLE handle; - Result result = - static_cast( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); - return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" ); + 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*/ @@ -10798,12 +10924,12 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; - Result result = - static_cast( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, - static_cast( handleType ), - handle, - reinterpret_cast( &memoryWin32HandleProperties ) ) ); - return createResultValue( result, memoryWin32HandleProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" ); + VkResult result = d.vkGetMemoryWin32HandlePropertiesKHR( m_device, + static_cast( handleType ), + 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*/ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -10826,9 +10952,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - int fd; - Result result = static_cast( d.vkGetMemoryFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); - return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" ); + 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*/ @@ -10851,9 +10978,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR memoryFdProperties; - Result result = static_cast( d.vkGetMemoryFdPropertiesKHR( - m_device, static_cast( handleType ), fd, reinterpret_cast( &memoryFdProperties ) ) ); - return createResultValue( result, memoryFdProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" ); + 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*/ @@ -10883,6 +11011,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast( &externalSemaphoreInfo ), reinterpret_cast( &externalSemaphoreProperties ) ); + return externalSemaphoreProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -10907,9 +11036,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &importSemaphoreWin32HandleInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" ); + 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*/ @@ -10929,10 +11059,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - HANDLE handle; - Result result = static_cast( - d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); - return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" ); + 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*/ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -10954,8 +11084,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast( &importSemaphoreFdInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" ); + 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*/ @@ -10975,9 +11106,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - int fd; - Result result = static_cast( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); - return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" ); + 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*/ @@ -11103,12 +11235,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; - Result result = static_cast( d.vkCreateDescriptorUpdateTemplateKHR( + VkResult result = d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &descriptorUpdateTemplate ) ) ); - return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHR" ); + reinterpret_cast( &descriptorUpdateTemplate ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHR" ); + return createResultValueType( static_cast( result ), descriptorUpdateTemplate ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -11220,13 +11353,11 @@ namespace VULKAN_HPP_NAMESPACE } #else template - VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE void PhysicalDevice::releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast( display ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::releaseDisplayEXT" ); + d.vkReleaseDisplayEXT( m_physicalDevice, static_cast( display ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11249,8 +11380,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast( display ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" ); + 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*/ @@ -11272,8 +11404,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DisplayKHR display; - Result result = static_cast( d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast( &display ) ) ); - return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXT" ); + 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 ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -11313,9 +11446,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT surfaceCapabilities; - Result result = static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( - m_physicalDevice, static_cast( surface ), reinterpret_cast( &surfaceCapabilities ) ) ); - return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" ); + 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*/ @@ -11339,9 +11473,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkDisplayPowerControlEXT( m_device, static_cast( display ), reinterpret_cast( &displayPowerInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" ); + 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*/ @@ -11368,12 +11503,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Fence fence; - Result result = static_cast( d.vkRegisterDeviceEventEXT( + VkResult result = d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast( &deviceEventInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &fence ) ) ); - return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXT" ); + reinterpret_cast( &fence ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXT" ); + return createResultValueType( static_cast( result ), fence ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -11422,13 +11558,14 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Fence fence; - Result result = static_cast( d.vkRegisterDisplayEventEXT( + VkResult result = d.vkRegisterDisplayEventEXT( m_device, static_cast( display ), reinterpret_cast( &displayEventInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &fence ) ) ); - return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXT" ); + reinterpret_cast( &fence ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXT" ); + return createResultValueType( static_cast( result ), fence ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -11473,9 +11610,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); uint64_t counterValue; - Result result = static_cast( - d.vkGetSwapchainCounterEXT( m_device, static_cast( swapchain ), static_cast( counter ), &counterValue ) ); - return createResultValue( result, counterValue, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainCounterEXT" ); + 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*/ @@ -11500,9 +11638,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties; - Result result = static_cast( d.vkGetRefreshCycleDurationGOOGLE( - m_device, static_cast( swapchain ), reinterpret_cast( &displayTimingProperties ) ) ); - return createResultValue( result, displayTimingProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getRefreshCycleDurationGOOGLE" ); + 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*/ @@ -11677,12 +11816,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::RenderPass renderPass; - Result result = static_cast( + VkResult result = d.vkCreateRenderPass2KHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &renderPass ) ) ); - return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHR" ); + reinterpret_cast( &renderPass ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHR" ); + return createResultValueType( static_cast( result ), renderPass ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -11783,14 +11923,16 @@ namespace VULKAN_HPP_NAMESPACE } #else template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, + Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkGetSwapchainStatusKHR( m_device, static_cast( swapchain ) ) ); - return createResultValue( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainStatusKHR", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); + VkResult result = d.vkGetSwapchainStatusKHR( m_device, static_cast( swapchain ) ); + 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*/ @@ -11819,6 +11961,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast( &externalFenceInfo ), reinterpret_cast( &externalFenceProperties ) ); + return externalFenceProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -11842,9 +11985,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast( &importFenceWin32HandleInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" ); + 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*/ @@ -11865,10 +12008,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - HANDLE handle; - Result result = - static_cast( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); - return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" ); + 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*/ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -11890,8 +12033,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkImportFenceFdKHR( m_device, reinterpret_cast( &importFenceFdInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" ); + 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*/ @@ -11911,9 +12055,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - int fd; - Result result = static_cast( d.vkGetFenceFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); - return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" ); + 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*/ @@ -12048,6 +12193,7 @@ namespace VULKAN_HPP_NAMESPACE uint32_t numPasses; d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( m_physicalDevice, reinterpret_cast( &performanceQueryCreateInfo ), &numPasses ); + return numPasses; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -12067,8 +12213,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast( &info ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" ); + 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*/ @@ -12101,11 +12248,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR surfaceCapabilities; - Result result = - static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, - reinterpret_cast( &surfaceInfo ), - reinterpret_cast( &surfaceCapabilities ) ) ); - return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); + VkResult result = d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, + reinterpret_cast( &surfaceInfo ), + reinterpret_cast( &surfaceCapabilities ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); + return createResultValueType( static_cast( result ), surfaceCapabilities ); } template @@ -12451,10 +12598,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR capabilities; - Result result = static_cast( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, - reinterpret_cast( &displayPlaneInfo ), - reinterpret_cast( &capabilities ) ) ); - return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" ); + VkResult result = d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, + 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*/ @@ -12484,12 +12632,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( + VkResult result = d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVK" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVK" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -12540,12 +12689,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( + VkResult result = d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVK" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVK" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -12587,8 +12737,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast( &nameInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" ); + 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*/ @@ -12607,8 +12758,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast( &tagInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" ); + 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*/ @@ -12726,12 +12878,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger; - Result result = static_cast( d.vkCreateDebugUtilsMessengerEXT( + VkResult result = d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &messenger ) ) ); - return createResultValue( result, messenger, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT" ); + reinterpret_cast( &messenger ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT" ); + return createResultValueType( static_cast( result ), messenger ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -12856,9 +13009,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID properties; - Result result = static_cast( - d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, &buffer, reinterpret_cast( &properties ) ) ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); + 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 ); } template @@ -12894,9 +13048,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); struct AHardwareBuffer * buffer; - Result result = static_cast( - d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast( &info ), &buffer ) ); - return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" ); + 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*/ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ @@ -12942,6 +13097,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT multisampleProperties; d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast( samples ), reinterpret_cast( &multisampleProperties ) ); + return multisampleProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -12968,6 +13124,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; } @@ -12981,6 +13138,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get(); d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -13005,6 +13163,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; } @@ -13018,6 +13177,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get(); d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -13104,12 +13264,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure; - Result result = static_cast( d.vkCreateAccelerationStructureKHR( + VkResult result = d.vkCreateAccelerationStructureKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &accelerationStructure ) ) ); - return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHR" ); + reinterpret_cast( &accelerationStructure ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHR" ); + return createResultValueType( static_cast( result ), accelerationStructure ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -13295,8 +13456,8 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result + Device::buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, ArrayProxy const & infos, ArrayProxy const & pBuildRangeInfos, Dispatch const & d ) const @@ -13311,16 +13472,17 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - Result result = static_cast( + VkResult result = d.vkBuildAccelerationStructuresKHR( m_device, static_cast( deferredOperation ), infos.size(), reinterpret_cast( infos.data() ), - reinterpret_cast( pBuildRangeInfos.data() ) ) ); - return createResultValue( - result, + reinterpret_cast( pBuildRangeInfos.data() ) ); + resultCheck( + 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*/ @@ -13336,18 +13498,20 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info, - Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result + Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info, + Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkCopyAccelerationStructureKHR( - m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); - return createResultValue( - result, + VkResult result = d.vkCopyAccelerationStructureKHR( + m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ); + resultCheck( + 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*/ @@ -13364,19 +13528,20 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result + Device::copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkCopyAccelerationStructureToMemoryKHR( - m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); - return createResultValue( - result, + VkResult result = d.vkCopyAccelerationStructureToMemoryKHR( + m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ); + resultCheck( + 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*/ @@ -13393,19 +13558,20 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result + Device::copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkCopyMemoryToAccelerationStructureKHR( - m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); - return createResultValue( - result, + VkResult result = d.vkCopyMemoryToAccelerationStructureKHR( + m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ); + resultCheck( + 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*/ @@ -13462,15 +13628,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); DataType data; - Result result = - static_cast( d.vkWriteAccelerationStructuresPropertiesKHR( m_device, - accelerationStructures.size(), - reinterpret_cast( accelerationStructures.data() ), - static_cast( queryType ), - sizeof( DataType ), - reinterpret_cast( &data ), - stride ) ); - return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" ); + VkResult result = d.vkWriteAccelerationStructuresPropertiesKHR( m_device, + accelerationStructures.size(), + reinterpret_cast( accelerationStructures.data() ), + static_cast( queryType ), + sizeof( DataType ), + 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*/ @@ -13542,14 +13708,16 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress + Device::getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VkDeviceAddress result = d.vkGetAccelerationStructureDeviceAddressKHR( m_device, reinterpret_cast( &info ) ); - return static_cast( result ); + + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -13614,6 +13782,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetDeviceAccelerationStructureCompatibilityKHR( m_device, reinterpret_cast( &versionInfo ), reinterpret_cast( &compatibility ) ); + return compatibility; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -13656,6 +13825,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &buildInfo ), maxPrimitiveCounts.data(), reinterpret_cast( &sizeInfo ) ); + return sizeInfo; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -13686,12 +13856,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; - Result result = static_cast( d.vkCreateSamplerYcbcrConversionKHR( + VkResult result = d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &ycbcrConversion ) ) ); - return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHR" ); + reinterpret_cast( &ycbcrConversion ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHR" ); + return createResultValueType( static_cast( result ), ycbcrConversion ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -13758,9 +13929,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = - static_cast( d.vkBindBufferMemory2KHR( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" ); + 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*/ @@ -13780,9 +13951,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = - static_cast( d.vkBindImageMemory2KHR( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" ); + 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*/ @@ -13805,9 +13976,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties; - Result result = static_cast( d.vkGetImageDrmFormatModifierPropertiesEXT( - m_device, static_cast( image ), reinterpret_cast( &properties ) ) ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageDrmFormatModifierPropertiesEXT" ); + 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*/ @@ -13836,12 +14008,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache; - Result result = static_cast( d.vkCreateValidationCacheEXT( + VkResult result = d.vkCreateValidationCacheEXT( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &validationCache ) ) ); - return createResultValue( result, validationCache, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXT" ); + reinterpret_cast( &validationCache ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXT" ); + return createResultValueType( static_cast( result ), validationCache ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -13933,9 +14106,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkMergeValidationCachesEXT( - m_device, static_cast( dstCache ), srcCaches.size(), reinterpret_cast( srcCaches.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergeValidationCachesEXT" ); + 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*/ @@ -14099,12 +14273,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure; - Result result = static_cast( d.vkCreateAccelerationStructureNV( + VkResult result = d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &accelerationStructure ) ) ); - return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNV" ); + reinterpret_cast( &accelerationStructure ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNV" ); + return createResultValueType( static_cast( result ), accelerationStructure ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -14202,6 +14377,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; } @@ -14217,6 +14393,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -14238,9 +14415,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkBindAccelerationStructureMemoryNV( - m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" ); + 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*/ @@ -14417,17 +14595,17 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Pipeline pipeline; - Result result = static_cast( d.vkCreateRayTracingPipelinesNV( + VkResult result = d.vkCreateRayTracingPipelinesNV( m_device, static_cast( pipelineCache ), 1, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &pipeline ) ) ); - return createResultValue( result, - pipeline, - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNV", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + reinterpret_cast( &pipeline ) ); + 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 @@ -14558,9 +14736,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); DataType data; - Result result = static_cast( d.vkGetRayTracingShaderGroupHandlesNV( - m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ) ); - return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleNV" ); + 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*/ @@ -14595,9 +14774,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); DataType data; - Result result = static_cast( d.vkGetAccelerationStructureHandleNV( - m_device, static_cast( accelerationStructure ), sizeof( DataType ), reinterpret_cast( &data ) ) ); - return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); + 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*/ @@ -14654,8 +14834,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkCompileDeferredNV( m_device, static_cast( pipeline ), shader ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::compileDeferredNV" ); + 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*/ @@ -14682,6 +14863,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support; d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); + return support; } @@ -14696,6 +14878,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = structureChain.template get(); d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -14766,12 +14949,12 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT memoryHostPointerProperties; - Result result = - static_cast( d.vkGetMemoryHostPointerPropertiesEXT( m_device, - static_cast( handleType ), - pHostPointer, - reinterpret_cast( &memoryHostPointerProperties ) ) ); - return createResultValue( result, memoryHostPointerProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" ); + VkResult result = d.vkGetMemoryHostPointerPropertiesEXT( m_device, + static_cast( handleType ), + 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*/ @@ -15070,8 +15253,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); uint64_t value; - Result result = static_cast( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast( semaphore ), &value ) ); - return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValueKHR" ); + 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*/ @@ -15086,15 +15270,16 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, - uint64_t timeout, - Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result + Device::waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkWaitSemaphoresKHR( m_device, reinterpret_cast( &waitInfo ), timeout ) ); - return createResultValue( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); + VkResult result = d.vkWaitSemaphoresKHR( m_device, reinterpret_cast( &waitInfo ), timeout ); + 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*/ @@ -15113,8 +15298,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkSignalSemaphoreKHR( m_device, reinterpret_cast( &signalInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" ); + 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*/ @@ -15136,9 +15322,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = - static_cast( d.vkInitializePerformanceApiINTEL( m_device, reinterpret_cast( &initializeInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" ); + 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*/ @@ -15164,9 +15350,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = - static_cast( d.vkCmdSetPerformanceMarkerINTEL( m_commandBuffer, reinterpret_cast( &markerInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" ); + 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*/ @@ -15186,9 +15372,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkCmdSetPerformanceStreamMarkerINTEL( m_commandBuffer, reinterpret_cast( &markerInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" ); + 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*/ @@ -15208,9 +15394,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = - static_cast( d.vkCmdSetPerformanceOverrideINTEL( m_commandBuffer, reinterpret_cast( &overrideInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" ); + 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*/ @@ -15234,11 +15420,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration; - Result result = - static_cast( d.vkAcquirePerformanceConfigurationINTEL( m_device, - reinterpret_cast( &acquireInfo ), - reinterpret_cast( &configuration ) ) ); - return createResultValue( result, configuration, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL" ); + VkResult result = d.vkAcquirePerformanceConfigurationINTEL( m_device, + reinterpret_cast( &acquireInfo ), + reinterpret_cast( &configuration ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL" ); + return createResultValueType( static_cast( result ), configuration ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -15275,8 +15461,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast( configuration ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releasePerformanceConfigurationINTEL" ); + 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*/ @@ -15295,8 +15482,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast( configuration ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::release" ); + 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*/ @@ -15315,8 +15503,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkQueueSetPerformanceConfigurationINTEL( m_queue, static_cast( configuration ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" ); + 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*/ @@ -15338,9 +15527,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::PerformanceValueINTEL value; - Result result = static_cast( d.vkGetPerformanceParameterINTEL( - m_device, static_cast( parameter ), reinterpret_cast( &value ) ) ); - return createResultValue( result, value, VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" ); + 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*/ @@ -15382,12 +15572,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( d.vkCreateImagePipeSurfaceFUCHSIA( + VkResult result = d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIA" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIA" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -15438,12 +15629,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( + VkResult result = d.vkCreateMetalSurfaceEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXT" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXT" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -15583,13 +15775,14 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress Device::getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VkDeviceAddress result = d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast( &info ) ); - return static_cast( result ); + + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15682,14 +15875,16 @@ namespace VULKAN_HPP_NAMESPACE } #else template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkWaitForPresentKHR( m_device, static_cast( swapchain ), presentId, timeout ) ); - return createResultValue( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresentKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); + VkResult result = d.vkWaitForPresentKHR( m_device, static_cast( swapchain ), presentId, timeout ); + resultCheck( static_cast( result ), + VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresentKHR", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -15949,8 +16144,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast( swapchain ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireFullScreenExclusiveModeEXT" ); + 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*/ @@ -15969,8 +16165,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast( swapchain ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseFullScreenExclusiveModeEXT" ); + 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*/ @@ -15993,9 +16190,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes; - Result result = static_cast( d.vkGetDeviceGroupSurfacePresentModes2EXT( - m_device, reinterpret_cast( &surfaceInfo ), reinterpret_cast( &modes ) ) ); - return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" ); + 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*/ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ @@ -16025,12 +16223,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( d.vkCreateHeadlessSurfaceEXT( + VkResult result = d.vkCreateHeadlessSurfaceEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXT" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXT" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -16066,13 +16265,14 @@ namespace VULKAN_HPP_NAMESPACE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress Device::getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VkDeviceAddress result = d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast( &info ) ); - return static_cast( result ); + + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -16092,6 +16292,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); uint64_t result = d.vkGetBufferOpaqueCaptureAddressKHR( m_device, reinterpret_cast( &info ) ); + return result; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -16112,6 +16313,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); uint64_t result = d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( m_device, reinterpret_cast( &info ) ); + return result; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -16332,11 +16534,12 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation; - Result result = static_cast( d.vkCreateDeferredOperationKHR( + VkResult result = d.vkCreateDeferredOperationKHR( m_device, reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &deferredOperation ) ) ); - return createResultValue( result, deferredOperation, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHR" ); + reinterpret_cast( &deferredOperation ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHR" ); + return createResultValueType( static_cast( result ), deferredOperation ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -16425,15 +16628,14 @@ namespace VULKAN_HPP_NAMESPACE } #else template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result + Device::getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkGetDeferredOperationResultKHR( m_device, static_cast( operation ) ) ); - return createResultValue( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::getDeferredOperationResultKHR", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); + VkResult result = d.vkGetDeferredOperationResultKHR( m_device, static_cast( operation ) ); + + return static_cast( result ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -16447,16 +16649,16 @@ namespace VULKAN_HPP_NAMESPACE } #else template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, - Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, + Dispatch const & d ) const { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkDeferredOperationJoinKHR( m_device, static_cast( operation ) ) ); - return createResultValue( - result, - VULKAN_HPP_NAMESPACE_STRING "::Device::deferredOperationJoinKHR", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR, VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR } ); + VkResult result = d.vkDeferredOperationJoinKHR( m_device, static_cast( operation ) ); + 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*/ @@ -16748,6 +16950,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetGeneratedCommandsMemoryRequirementsNV( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; } @@ -16763,6 +16966,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetGeneratedCommandsMemoryRequirementsNV( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -16843,12 +17047,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout; - Result result = static_cast( d.vkCreateIndirectCommandsLayoutNV( + VkResult result = d.vkCreateIndirectCommandsLayoutNV( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &indirectCommandsLayout ) ) ); - return createResultValue( result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNV" ); + reinterpret_cast( &indirectCommandsLayout ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNV" ); + return createResultValueType( static_cast( result ), indirectCommandsLayout ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -16940,8 +17145,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkAcquireDrmDisplayEXT( m_physicalDevice, drmFd, static_cast( display ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT" ); + 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*/ @@ -16963,8 +17169,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DisplayKHR display; - Result result = static_cast( d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast( &display ) ) ); - return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXT" ); + 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 ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -17007,12 +17214,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; - Result result = static_cast( d.vkCreatePrivateDataSlotEXT( + VkResult result = d.vkCreatePrivateDataSlotEXT( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &privateDataSlot ) ) ); - return createResultValue( result, privateDataSlot, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXT" ); + reinterpret_cast( &privateDataSlot ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXT" ); + return createResultValueType( static_cast( result ), privateDataSlot ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -17082,9 +17290,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkSetPrivateDataEXT( m_device, static_cast( objectType ), objectHandle, static_cast( privateDataSlot ), data ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT" ); + 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*/ @@ -17110,6 +17319,7 @@ namespace VULKAN_HPP_NAMESPACE uint64_t data; d.vkGetPrivateDataEXT( m_device, static_cast( objectType ), objectHandle, static_cast( privateDataSlot ), &data ); + return data; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -17250,9 +17460,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( - d.vkQueueSubmit2KHR( m_queue, submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" ); + 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*/ @@ -17455,8 +17665,9 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast( display ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV" ); + 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*/ @@ -17477,8 +17688,9 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::DisplayKHR display; - Result result = static_cast( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast( &display ) ) ); - return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" ); + 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 ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -17523,12 +17735,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( d.vkCreateDirectFBSurfaceEXT( + VkResult result = d.vkCreateDirectFBSurfaceEXT( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -17563,14 +17776,14 @@ namespace VULKAN_HPP_NAMESPACE # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, - IDirectFB & dfb, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 + PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VkBool32 result = d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, &dfb ); - return static_cast( result ); + + return static_cast( result ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ @@ -17712,21 +17925,21 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Pipeline pipeline; - Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( + VkResult result = d.vkCreateRayTracingPipelinesKHR( m_device, static_cast( deferredOperation ), static_cast( pipelineCache ), 1, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &pipeline ) ) ); - return createResultValue( result, - pipeline, - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineKHR", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, - VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, - VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR, - VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT } ); + reinterpret_cast( &pipeline ) ); + resultCheck( static_cast( result ), + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineKHR", + { VULKAN_HPP_NAMESPACE::Result::eSuccess, + 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 @@ -17874,9 +18087,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); DataType data; - Result result = static_cast( d.vkGetRayTracingShaderGroupHandlesKHR( - m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ) ); - return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleKHR" ); + 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*/ @@ -17914,9 +18128,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); DataType data; - Result result = static_cast( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( - m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ) ); - return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandleKHR" ); + 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*/ @@ -18031,9 +18246,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); zx_handle_t zirconHandle; - Result result = static_cast( - d.vkGetMemoryZirconHandleFUCHSIA( m_device, reinterpret_cast( &getZirconHandleInfo ), &zirconHandle ) ); - return createResultValue( result, zirconHandle, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" ); + 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*/ @@ -18062,12 +18278,12 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties; - Result result = static_cast( - d.vkGetMemoryZirconHandlePropertiesFUCHSIA( m_device, - static_cast( handleType ), - zirconHandle, - reinterpret_cast( &memoryZirconHandleProperties ) ) ); - return createResultValue( result, memoryZirconHandleProperties, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" ); + VkResult result = d.vkGetMemoryZirconHandlePropertiesFUCHSIA( m_device, + static_cast( handleType ), + 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*/ #endif /*VK_USE_PLATFORM_FUCHSIA*/ @@ -18092,9 +18308,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkImportSemaphoreZirconHandleFUCHSIA( - m_device, reinterpret_cast( &importSemaphoreZirconHandleInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" ); + 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*/ @@ -18117,9 +18334,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); zx_handle_t zirconHandle; - Result result = static_cast( - d.vkGetSemaphoreZirconHandleFUCHSIA( m_device, reinterpret_cast( &getZirconHandleInfo ), &zirconHandle ) ); - return createResultValue( result, zirconHandle, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" ); + 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*/ #endif /*VK_USE_PLATFORM_FUCHSIA*/ @@ -18151,12 +18369,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection; - Result result = static_cast( d.vkCreateBufferCollectionFUCHSIA( + VkResult result = d.vkCreateBufferCollectionFUCHSIA( m_device, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &collection ) ) ); - return createResultValue( result, collection, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIA" ); + reinterpret_cast( &collection ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIA" ); + return createResultValueType( static_cast( result ), collection ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -18200,9 +18419,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkSetBufferCollectionImageConstraintsFUCHSIA( - m_device, static_cast( collection ), reinterpret_cast( &imageConstraintsInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setBufferCollectionImageConstraintsFUCHSIA" ); + 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*/ @@ -18226,9 +18446,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - Result result = static_cast( d.vkSetBufferCollectionBufferConstraintsFUCHSIA( - m_device, static_cast( collection ), reinterpret_cast( &bufferConstraintsInfo ) ) ); - return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setBufferCollectionBufferConstraintsFUCHSIA" ); + 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*/ @@ -18301,9 +18522,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA properties; - Result result = static_cast( d.vkGetBufferCollectionPropertiesFUCHSIA( - m_device, static_cast( collection ), reinterpret_cast( &properties ) ) ); - return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferCollectionPropertiesFUCHSIA" ); + 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*/ #endif /*VK_USE_PLATFORM_FUCHSIA*/ @@ -18328,12 +18550,12 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::Extent2D maxWorkgroupSize; - Result result = static_cast( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( - m_device, static_cast( renderpass ), reinterpret_cast( &maxWorkgroupSize ) ) ); - return createResultValue( result, - maxWorkgroupSize, - VULKAN_HPP_NAMESPACE_STRING "::Device::getSubpassShadingMaxWorkgroupSizeHUAWEI", - { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete } ); + VkResult result = d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( + m_device, static_cast( renderpass ), reinterpret_cast( &maxWorkgroupSize ) ); + 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*/ @@ -18376,9 +18598,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::RemoteAddressNV address; - Result result = static_cast( d.vkGetMemoryRemoteAddressNV( - m_device, reinterpret_cast( &memoryGetRemoteAddressInfo ), reinterpret_cast( &address ) ) ); - return createResultValue( result, address, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" ); + 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*/ @@ -18447,12 +18670,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( d.vkCreateScreenSurfaceQNX( + VkResult result = d.vkCreateScreenSurfaceQNX( m_instance, reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), - reinterpret_cast( &surface ) ) ); - return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNX" ); + reinterpret_cast( &surface ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNX" ); + return createResultValueType( static_cast( result ), surface ); } # ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -18487,14 +18711,14 @@ namespace VULKAN_HPP_NAMESPACE # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, - struct _screen_window & window, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 + PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window & window, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VkBool32 result = d.vkGetPhysicalDeviceScreenPresentationSupportQNX( m_physicalDevice, queueFamilyIndex, &window ); - return static_cast( result ); + + return static_cast( result ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ @@ -18616,6 +18840,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; d.vkGetDeviceBufferMemoryRequirementsKHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; } @@ -18629,6 +18854,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get(); d.vkGetDeviceBufferMemoryRequirementsKHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -18653,6 +18879,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; d.vkGetDeviceImageMemoryRequirementsKHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; } @@ -18666,6 +18893,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get(); d.vkGetDeviceImageMemoryRequirementsKHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -18751,6 +18979,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkGetDescriptorSetLayoutHostMappingInfoVALVE( m_device, reinterpret_cast( &bindingReference ), reinterpret_cast( &hostMapping ) ); + return hostMapping; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -18772,6 +19001,7 @@ namespace VULKAN_HPP_NAMESPACE void * pData; d.vkGetDescriptorSetHostMappingVALVE( m_device, static_cast( descriptorSet ), &pData ); + return pData; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ diff --git a/vulkan/vulkan_handles.hpp b/vulkan/vulkan_handles.hpp index 2dee016..689d21a 100644 --- a/vulkan/vulkan_handles.hpp +++ b/vulkan/vulkan_handles.hpp @@ -6712,8 +6712,8 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ //=== VK_EXT_debug_utils === @@ -7404,7 +7404,8 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #else template - VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -7415,10 +7416,10 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD Result waitForFences( ArrayProxy const & fences, - VULKAN_HPP_NAMESPACE::Bool32 waitAll, - uint64_t timeout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForFences( ArrayProxy const & fences, + VULKAN_HPP_NAMESPACE::Bool32 waitAll, + uint64_t timeout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -7511,7 +7512,8 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #else template - VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -8209,9 +8211,9 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #else template - typename ResultValueType::type resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, - VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + void resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, + VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -8254,9 +8256,9 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - typename ResultValueType::type freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, - ArrayProxy const & descriptorSets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + void freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, + ArrayProxy const & descriptorSets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -8266,9 +8268,9 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - typename ResultValueType::type( free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, - ArrayProxy const & descriptorSets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + void( free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool, + ArrayProxy const & descriptorSets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -8751,9 +8753,9 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, - uint64_t timeout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, + uint64_t timeout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -8770,8 +8772,8 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -9692,8 +9694,8 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #else template - VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #if defined( VK_USE_PLATFORM_WIN32_KHR ) @@ -9914,11 +9916,11 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD Result - buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - ArrayProxy const & infos, - ArrayProxy const & pBuildRangeInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result + buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + ArrayProxy const & infos, + ArrayProxy const & pBuildRangeInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -9927,9 +9929,9 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -9938,9 +9940,10 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result + copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -9949,9 +9952,10 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result + copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -9984,8 +9988,9 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - DeviceAddress getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NAMESPACE::DeviceAddress + getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -10408,9 +10413,9 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, - uint64_t timeout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, + uint64_t timeout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -10500,8 +10505,8 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ //=== VK_KHR_present_wait === @@ -10514,10 +10519,10 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #else template - VULKAN_HPP_NODISCARD Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, - uint64_t presentId, - uint64_t timeout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, + uint64_t presentId, + uint64_t timeout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #if defined( VK_USE_PLATFORM_WIN32_KHR ) @@ -10562,8 +10567,8 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -10643,8 +10648,9 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #else template - VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result + getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -10653,8 +10659,8 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #else template - VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ //=== VK_KHR_pipeline_executable_properties === @@ -11921,10 +11927,10 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, - Display & dpy, - VisualID visualID, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, + Display & dpy, + VisualID visualID, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_XLIB_KHR*/ @@ -11938,10 +11944,10 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, - xcb_connection_t & connection, - xcb_visualid_t visual_id, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NAMESPACE::Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, + xcb_connection_t & connection, + xcb_visualid_t visual_id, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_XCB_KHR*/ @@ -11954,9 +11960,9 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, - struct wl_display & display, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, + struct wl_display & display, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ @@ -12174,8 +12180,7 @@ namespace VULKAN_HPP_NAMESPACE Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #else template - typename ResultValueType::type releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + void releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) @@ -12582,9 +12587,9 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, - IDirectFB & dfb, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, + IDirectFB & dfb, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ @@ -12597,9 +12602,9 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, - struct _screen_window & window, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, + struct _screen_window & window, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_SCREEN_QNX*/