From 75ce35813dfb2aed8caba1031b1cfc2fd0c545a9 Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Tue, 20 Oct 2020 12:27:08 +0200 Subject: [PATCH] Refactor commands enumerating some non-handle, non-StructureChain data type. --- VulkanHppGenerator.cpp | 444 ++++++----- VulkanHppGenerator.hpp | 23 +- vulkan/vulkan.hpp | 1654 ++++++++++++++++++++++------------------ 3 files changed, 1176 insertions(+), 945 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index d446e9f..ceccbdc 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -57,7 +57,6 @@ std::string createEnumValueName( std::string const & name, std::string createSuccessCode( std::string const & code, std::set const & tags ); std::string determineCommandName( std::string const & vulkanCommandName, std::string const & firstArgumentType ); std::set determineSkippedParams( size_t returnParamIndex, std::map const & vectorParamIndices ); -bool determineStructureChaining( std::string const & structType, std::set const & extendedStructs ); std::string extractTag( int line, std::string const & name, std::set const & tags ); std::string findTag( std::set const & tags, std::string const & name, std::string const & postfix = "" ); std::pair generateFunctionBodyStandardReturn( std::string const & returnType ); @@ -391,11 +390,6 @@ std::set determineSkippedParams( size_t returnParamIndex, std::map const & extendedStructs ) -{ - return ( extendedStructs.find( structType ) != extendedStructs.end() ); -} - std::string findTag( std::set const & tags, std::string const & name, std::string const & postfix ) { auto tagIt = std::find_if( @@ -858,7 +852,7 @@ void VulkanHppGenerator::appendArguments( std::string & str, } else if ( beginsWith( commandData.params[i].type.type, "Vk" ) ) { - appendArgumentVulkanType( str, commandData.params[i] ); + str += "static_cast<" + commandData.params[i].type.type + ">( " + commandData.params[i].name + " )"; } else { @@ -895,12 +889,6 @@ void VulkanHppGenerator::appendArgumentVector( std::string & str, appendReinterpretCast( str, paramData.type.prefix.find( "const" ) == 0, paramData.type.type ); str += "( " + parameterName + ".data() )"; } - else if ( paramData.type.type == "char" ) - { - // the parameter is a vector to char -> it might be optional - // besides that, the parameter now is a std::string -> get the pointer via c_str() - str += parameterName + ( paramData.optional ? ( " ? " + parameterName + "->c_str() : nullptr" ) : ".c_str()" ); - } else { // this parameter is just a vetor -> get the pointer to its data @@ -909,27 +897,6 @@ void VulkanHppGenerator::appendArgumentVector( std::string & str, } } -void VulkanHppGenerator::appendArgumentVulkanType( std::string & str, ParamData const & paramData ) const -{ - // this parameter is a vulkan type - if ( !paramData.type.postfix.empty() || !paramData.arraySizes.empty() ) - { - assert( ( paramData.type.postfix.empty() || ( paramData.type.postfix.back() == '*' ) ) && - ( paramData.arraySizes.empty() || ( paramData.arraySizes.size() == 1 ) ) ); - // it's a pointer -> needs a reinterpret cast to the vulkan type - std::string parameterName = startLowerCase( stripPrefix( paramData.name, "p" ) ); - appendReinterpretCast( str, paramData.type.prefix.find( "const" ) != std::string::npos, paramData.type.type ); - assert( !paramData.optional ); - // those parameters can just use the pointer - str += std::string( "( " ) + ( paramData.arraySizes.empty() ? "&" : "" ) + parameterName + " )"; - } - else - { - // a non-pointer parameter needs a static_cast from VULKAN_HPP_NAMESPACE-type to vulkan type - str += "static_cast<" + paramData.type.type + ">( " + paramData.name + " )"; - } -} - void VulkanHppGenerator::appendBaseTypes( std::string & str ) const { assert( !m_baseTypes.empty() ); @@ -1267,38 +1234,48 @@ void VulkanHppGenerator::appendCommand( std::string & str, break; case 2: // two return parameters - switch ( vectorParamIndices.size() ) + if ( !isHandleType( commandData.params[nonConstPointerParamIndices[0]].type.type ) && + !isHandleType( commandData.params[nonConstPointerParamIndices[1]].type.type ) && + !isStructureChainAnchor( commandData.params[nonConstPointerParamIndices[0]].type.type ) && + !isStructureChainAnchor( commandData.params[nonConstPointerParamIndices[1]].type.type ) ) { - case 1: + // non of the return parameters is a handle or a StructureChain + switch ( vectorParamIndices.size() ) { - // two returns but just one vector -> the size is a return value as well -> enumerate the values - auto vectorParamIndexIt = vectorParamIndices.begin(); - assert( ( vectorParamIndexIt->second == nonConstPointerParamIndices[0] ) && - ( vectorParamIndexIt->first == nonConstPointerParamIndices[1] ) ); - if ( ( commandData.returnType == "void" ) && - !determineStructureChaining( commandData.params[vectorParamIndexIt->first].type.type, - m_extendedStructs ) ) + case 1: { - assert( commandData.params[vectorParamIndexIt->first].type.type != "void" ); - // provide standard, enhanced, and vector calls - appendCommandVector( str, name, commandData, *vectorParamIndexIt, definition ); + // two returns but just one vector + auto vectorParamIndexIt = vectorParamIndices.begin(); + if ( ( vectorParamIndexIt->second == nonConstPointerParamIndices[0] ) && + ( vectorParamIndexIt->first == nonConstPointerParamIndices[1] ) && + ( commandData.params[vectorParamIndexIt->first].type.type != "void" ) ) + { + // the size is a return value as well -> enumerate the values + // and the vector data is not of type void + if ( ( commandData.returnType == "VkResult" ) || ( commandData.returnType == "void" ) ) + { + // provide standard, enhanced, and vector calls + appendCommandVector( str, name, commandData, *vectorParamIndexIt, definition ); + appendedFunction = true; + } + } + } + break; + case 2: + { + // two returns and two vectors! But one input vector, one output vector of the same size, and one output + // value + assert( vectorParamIndices.find( nonConstPointerParamIndices[0] ) != vectorParamIndices.end() ); + assert( vectorParamIndices.find( nonConstPointerParamIndices[1] ) == vectorParamIndices.end() ); + assert( commandData.returnType == "VkResult" ); + // provide standard, enhanced deprecated, enhanced, and enhanced with allocator calls + appendCommandStandardEnhancedDeprecatedAllocator( + str, name, commandData, definition, vectorParamIndices, nonConstPointerParamIndices ); appendedFunction = true; } + break; + default: break; } - break; - case 2: - { - // two returns and two vectors! But one input vector, one output vector of the same size, and one output value - assert( vectorParamIndices.find( nonConstPointerParamIndices[0] ) != vectorParamIndices.end() ); - assert( vectorParamIndices.find( nonConstPointerParamIndices[1] ) == vectorParamIndices.end() ); - assert( commandData.returnType == "VkResult" ); - // provide standard, enhanced deprecated, enhanced, and enhanced with allocator calls - appendCommandStandardEnhancedDeprecatedAllocator( - str, name, commandData, definition, vectorParamIndices, nonConstPointerParamIndices ); - appendedFunction = true; - } - break; - default: break; } break; case 3: @@ -1355,11 +1332,10 @@ void VulkanHppGenerator::appendCommand( std::string & str, size_t returnParamIndex = determineReturnParamIndex( commandData, vectorParamIndices, twoStep ); bool isStructureChain = ( returnParamIndex != INVALID_INDEX ) && - determineStructureChaining( commandData.params[returnParamIndex].type.type, m_extendedStructs ); + ( m_extendedStructs.find( commandData.params[returnParamIndex].type.type ) != m_extendedStructs.end() ); std::string enhancedReturnType = determineEnhancedReturnType( commandData, returnParamIndex, - vectorParamIndices, false ); // get the enhanced return type without structureChain size_t templateParamIndex = determineTemplateParamIndex( commandData.params, vectorParamIndices ); @@ -1416,7 +1392,7 @@ void VulkanHppGenerator::appendCommand( std::string & str, if ( isStructureChain ) { std::string enhancedReturnTypeWithStructureChain = - determineEnhancedReturnType( commandData, returnParamIndex, vectorParamIndices, true ); + determineEnhancedReturnType( commandData, returnParamIndex, true ); appendFunction( enhanced, indentation, name, @@ -1472,16 +1448,7 @@ void VulkanHppGenerator::appendCommand( std::string & str, // standard and enhanced string differ -> use both, wrapping the enhanced by !VULKAN_HPP_DISABLE_ENHANCED_MODE // determine the argument list of that standard, and compare it with that of the enhanced // if they are equal -> need to have just one; if they differ -> need to have both - size_t standardStart = standard.find( '(' ); - size_t standardCount = standard.find( ')', standardStart ) - standardStart; - size_t enhancedStart = enhanced.find( '(' ); - bool unchangedInterface = - ( standard.substr( standardStart, standardCount ) == enhanced.substr( enhancedStart, standardCount ) ); - if ( unchangedInterface ) - { - str += "#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE\n"; - } - str += standard + ( unchangedInterface ? "#else" : "#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE" ) + "\n" + enhanced + + str += standard + "#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE" + "\n" + enhanced + "#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/\n"; } str += leave; @@ -1588,11 +1555,10 @@ ${leave})"; std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions ); str += replaceWithMap( functionTemplate, - std::map( { - { "commandStandard", constructCommandStandard( name, commandData, definition ) }, - { "enter", enter }, - { "leave", leave } - } ) ); + std::map( + { { "commandStandard", constructCommandStandard( name, commandData, definition ) }, + { "enter", enter }, + { "leave", leave } } ) ); } void VulkanHppGenerator::appendCommandStandardAndEnhanced( @@ -1766,28 +1732,34 @@ void VulkanHppGenerator::appendCommandVector( std::string & std::pair const & vectorParamIndex, bool definition ) const { - assert( commandData.returnType == "void" ); + assert( ( commandData.returnType == "VkResult" ) || ( commandData.returnType == "void" ) ); std::string enter, leave; std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions ); - assert( enter.empty() ); const std::string functionTemplate = R"( -${commandStandard}${newlineOnDefinition} +${enter}${commandStandard}${newlineOnDefinition} #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE ${commandEnhanced}${newlineOnDefinition} ${commandEnhancedWithAllocators} #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -)"; +${leave})"; - str += replaceWithMap( - functionTemplate, - std::map( - { { "commandEnhanced", constructCommandVoidEnumerate( name, commandData, definition, vectorParamIndex, false ) }, - { "commandEnhancedWithAllocators", - constructCommandVoidEnumerate( name, commandData, definition, vectorParamIndex, true ) }, - { "commandStandard", constructCommandStandard( name, commandData, definition ) }, - { "newlineOnDefinition", definition ? "\n" : "" } } ) ); + str += + replaceWithMap( functionTemplate, + std::map( + { { "commandEnhanced", + ( commandData.returnType == "VkResult" ) + ? constructCommandResultEnumerate( name, commandData, definition, vectorParamIndex, false ) + : constructCommandVoidEnumerate( name, commandData, definition, vectorParamIndex, false ) }, + { "commandEnhancedWithAllocators", + ( commandData.returnType == "VkResult" ) + ? constructCommandResultEnumerate( name, commandData, definition, vectorParamIndex, true ) + : constructCommandVoidEnumerate( name, commandData, definition, vectorParamIndex, true ) }, + { "commandStandard", constructCommandStandard( name, commandData, definition ) }, + { "enter", enter }, + { "leave", leave }, + { "newlineOnDefinition", definition ? "\n" : "" } } ) ); } void VulkanHppGenerator::appendCommandVectorDeprecated( std::string & str, @@ -2826,9 +2798,7 @@ bool VulkanHppGenerator::appendFunctionHeaderArgumentEnhanced( std::string & std::map const & vectorParamIndices, bool skip, bool argEncountered, - bool isTemplateParam, - bool withDefaults, - bool withAllocator ) const + bool isTemplateParam ) const { if ( !skip ) { @@ -2858,7 +2828,7 @@ bool VulkanHppGenerator::appendFunctionHeaderArgumentEnhanced( std::string & { // the argument is a vector appendFunctionHeaderArgumentEnhancedVector( - str, param, strippedParameterName, it->second != INVALID_INDEX, isTemplateParam, withDefaults, withAllocator ); + str, param, strippedParameterName, it->second != INVALID_INDEX, isTemplateParam ); } argEncountered = true; } @@ -2881,36 +2851,20 @@ void VulkanHppGenerator::appendFunctionHeaderArgumentEnhancedVector( std::string ParamData const & param, std::string const & strippedParameterName, bool hasSizeParam, - bool isTemplateParam, - bool withDefaults, - bool withAllocator ) const + bool isTemplateParam ) const { assert( param.type.postfix.back() == '*' ); // it's optional, if it's marked as optional and there's no size specified bool optional = param.optional && !hasSizeParam; - bool useString = ( param.type.type.find( "char" ) != std::string::npos ); std::string optionalBegin = optional ? "Optional<" : ""; - std::string optionalEnd = optional ? "> " : ( useString ? " & " : "" ); + std::string optionalEnd = optional ? "> " : ""; - if ( useString ) - { - // it's a char-vector -> use a std::string - assert( param.type.prefix.find( "const" ) != std::string::npos ); - str += optionalBegin + "const std::string" + optionalEnd + strippedParameterName; - if ( optional && withDefaults && !withAllocator ) - { - str += " VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT"; - } - } - else - { - // otherwise, use our ArrayProxy - bool isConst = ( param.type.prefix.find( "const" ) != std::string::npos ); - str += optionalBegin + "ArrayProxy<" + - ( isTemplateParam ? ( isConst ? "const T" : "T" ) : stripPostfix( param.type.compose(), "*" ) ) + - "> const &" + optionalEnd + strippedParameterName; - } + // use our ArrayProxy + bool isConst = ( param.type.prefix.find( "const" ) != std::string::npos ); + str += optionalBegin + "ArrayProxy<" + + ( isTemplateParam ? ( isConst ? "const T" : "T" ) : stripPostfix( param.type.compose(), "*" ) ) + + "> const &" + optionalEnd + strippedParameterName; } void VulkanHppGenerator::appendFunctionHeaderArguments( std::string & str, @@ -2957,7 +2911,7 @@ void VulkanHppGenerator::appendFunctionHeaderReturnType( std::string & str CommandData const & commandData, size_t #if !defined( NDEBUG ) - returnParamIndex + returnParamIndex #endif , std::string const & enhancedReturnType, @@ -3582,7 +3536,7 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector " + - startLowerCase( - stripPrefix( params[i].name, "p" ) + - ( ( definition || withAllocators ) ? "" : " VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT" ) ); + name + + ( ( definition || withAllocators ) ? "" : " VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT" ); hasDefaultAssignment = true; } else { - argumentList += params[i].type.prefix + " " + stripPrefix( params[i].type.type, "Vk" ) + " & " + - startLowerCase( stripPrefix( params[i].name, "p" ) ); + argumentList += params[i].type.prefix + " " + stripPrefix( params[i].type.type, "Vk" ) + " & " + name; } } else @@ -3628,7 +3581,17 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector " + name + + ( ( definition || withAllocators ) ? "" : " VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT" ); + hasDefaultAssignment = true; + } + else + { + argumentList += "const std::string & " + name; + } } else { @@ -3641,9 +3604,8 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector const & "; + argumentList += "ArrayProxy<" + type + "> const & " + name; } - argumentList += startLowerCase( stripPrefix( params[i].name, "p" ) ); } } else if ( params[i].type.isNonConstPointer() ) @@ -3714,7 +3676,8 @@ std::string VulkanHppGenerator::constructCallArgument( ParamData const & param, assert( !param.type.isValue() ); assert( param.type.type == "char" ); assert( beginsWith( param.name, "p" ) ); - argument = startLowerCase( stripPrefix( param.name, "p" ) ) + ".c_str()"; + argument = startLowerCase( stripPrefix( param.name, "p" ) ); + argument = param.optional ? ( argument + " ? " + argument + "->c_str() : nullptr" ) : ( argument + ".c_str()" ); } else if ( enhanced && ( param.type.type == "Display" ) ) { @@ -3761,17 +3724,28 @@ std::string VulkanHppGenerator::constructCallArgument( ParamData const & param, } std::string - VulkanHppGenerator::constructCallArgumentsEnumerateVectors( std::vector const & params, + VulkanHppGenerator::constructCallArgumentsEnumerateVectors( std::string const & handle, + std::vector const & params, std::map const & vectorParamIndices, bool vectorAsNullptr ) const { size_t countIndex = vectorParamIndices.begin()->second; assert( ( vectorParamIndices.size() != 2 ) || ( std::next( vectorParamIndices.begin() )->second == countIndex ) ); - std::string arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) ); - for ( size_t i = 1; i < params.size(); i++ ) + std::string arguments; + size_t i = 0; + if ( !handle.empty() ) { - arguments += ", "; + assert( handle == params[0].type.type ); + arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) ); + ++i; + } + for ( ; i < params.size(); i++ ) + { + if ( 0 < i ) + { + arguments += ", "; + } if ( i == countIndex ) { assert( !params[i].type.isValue() ); @@ -3835,13 +3809,21 @@ std::string VulkanHppGenerator::constructCallArgumentsGetValue( std::string cons return arguments; } -std::string VulkanHppGenerator::constructCallArgumentsGetVector( std::vector const & params, +std::string VulkanHppGenerator::constructCallArgumentsGetVector( std::string const & handle, + std::vector const & params, std::vector const & returnParamIndices, std::map const & vectorParamIndices, bool singular ) const { - std::string arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) ); - for ( size_t i = 1; i < params.size(); i++ ) + std::string arguments; + size_t i = 0; + if ( !handle.empty() ) + { + assert( handle == params[0].type.type ); + arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) ); + ++i; + } + for ( ; i < params.size(); i++ ) { arguments += ", "; auto vpiIt = vectorParamIndices.find( i ); @@ -4041,6 +4023,104 @@ std::string VulkanHppGenerator::constructCommandResult( std::string const & return str; } +std::string VulkanHppGenerator::constructCommandResultEnumerate( std::string const & name, + CommandData const & commandData, + bool definition, + std::pair const & vectorParamIndices, + bool withAllocator ) const +{ + assert( commandData.returnType == "VkResult" ); + assert( ( commandData.successCodes.size() == 2 ) && ( commandData.successCodes[0] == "VK_SUCCESS" ) && + ( commandData.successCodes[1] == "VK_INCOMPLETE" ) ); + + std::string str; + + std::set skippedParams = determineSkippedParams( commandData.handle, + commandData.params, + { vectorParamIndices }, + { vectorParamIndices.second, vectorParamIndices.first } ); + + std::string argumentList = + constructArgumentListEnhanced( commandData.params, skippedParams, INVALID_INDEX, definition, withAllocator ); + std::string commandName = determineCommandName( name, commandData.params[0].type.type ); + std::string nodiscard = constructNoDiscardEnhanced( commandData ); + std::string vectorElementType = stripPrefix( commandData.params[vectorParamIndices.first].type.type, "Vk" ); + + if ( definition ) + { + const std::string functionTemplate = + R"( template + ${nodiscard}VULKAN_HPP_INLINE typename ResultValueType>::type ${className}${commandName}( ${argumentList} )${const} + { + std::vector<${vectorElementType}, ${vectorElementType}Allocator> ${vectorName}${vectorAllocator}; + ${counterType} ${counterName}; + Result result; + do + { + result = static_cast( d.${vkCommand}( ${firstCallArguments} ) ); + if ( ( result == Result::eSuccess ) && ${counterName} ) + { + ${vectorName}.resize( ${counterName} ); + result = static_cast( d.${vkCommand}( ${secondCallArguments} ) ); + VULKAN_HPP_ASSERT( ${counterName} <= ${vectorName}.size() ); + } + } while ( result == Result::eIncomplete ); + if ( ( result == Result::eSuccess ) && ( ${counterName} < ${vectorName}.size() ) ) + { + ${vectorName}.resize( ${counterName} ); + } + return createResultValue( result, ${vectorName}, VULKAN_HPP_NAMESPACE_STRING"::${className}${commandName}" ); + })"; + + std::string withAllocatorsTypenameCheck = + ", typename B, typename std::enable_if::value, int>::type "; + + str = replaceWithMap( + functionTemplate, + std::map( + { { "argumentList", argumentList }, + { "className", commandData.handle.empty() ? "" : ( stripPrefix( commandData.handle, "Vk" ) + "::" ) }, + { "commandName", commandName }, + { "const", commandData.handle.empty() ? "" : " const" }, + { "counterName", startLowerCase( stripPrefix( commandData.params[vectorParamIndices.second].name, "p" ) ) }, + { "counterType", commandData.params[vectorParamIndices.second].type.type }, + { "firstCallArguments", + constructCallArgumentsEnumerateVectors( + commandData.handle, commandData.params, { vectorParamIndices }, true ) }, + { "nodiscard", nodiscard }, + { "secondCallArguments", + constructCallArgumentsEnumerateVectors( + commandData.handle, commandData.params, { vectorParamIndices }, false ) }, + { "vectorAllocator", withAllocator ? ( "( " + startLowerCase( vectorElementType ) + "Allocator )" ) : "" }, + { "vectorElementType", vectorElementType }, + { "vectorName", startLowerCase( stripPrefix( commandData.params[vectorParamIndices.first].name, "p" ) ) }, + { "vkCommand", name }, + { "withAllocatorTypenameCheck", withAllocator ? withAllocatorsTypenameCheck : "" } } ) ); + } + else + { + const std::string functionTemplate = + R"( template , typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${withAllocatorTypenameCheck}> + ${nodiscard}typename ResultValueType>::type ${commandName}( ${argumentList} )${const};)"; + + std::string withAllocatorsTypenameCheck = + ", typename B = " + vectorElementType + + "Allocator, typename std::enable_if::value, int>::type = 0"; + + str = replaceWithMap( functionTemplate, + std::map( + { { "argumentList", argumentList }, + { "const", commandData.handle.empty() ? "" : " const" }, + { "commandName", commandName }, + { "nodiscard", nodiscard }, + { "vectorElementType", vectorElementType }, + { "withAllocatorTypenameCheck", withAllocator ? withAllocatorsTypenameCheck : "" } } ) ); + } + return str; +} + std::string VulkanHppGenerator::constructCommandResultEnumerateTwoVectors( std::string const & name, CommandData const & commandData, @@ -4118,7 +4198,8 @@ std::string startLowerCase( stripPrefix( stripPluralS( commandData.params[firstVectorParamIt->second].name ), "p" ) ) }, { "counterType", commandData.params[firstVectorParamIt->second].type.type }, { "firstCallArguments", - constructCallArgumentsEnumerateVectors( commandData.params, vectorParamIndices, true ) }, + constructCallArgumentsEnumerateVectors( + commandData.handle, commandData.params, vectorParamIndices, true ) }, { "firstVectorName", startLowerCase( stripPrefix( commandData.params[firstVectorParamIt->first].name, "p" ) ) }, { "nodiscard", nodiscard }, @@ -4131,7 +4212,8 @@ std::string "Allocator ) )" ) : "" }, { "secondCallArguments", - constructCallArgumentsEnumerateVectors( commandData.params, vectorParamIndices, false ) }, + constructCallArgumentsEnumerateVectors( + commandData.handle, commandData.params, vectorParamIndices, false ) }, { "secondVectorName", startLowerCase( stripPrefix( commandData.params[secondVectorParamIt->first].name, "p" ) ) }, { "templateTypeFirst", templateTypeFirst }, @@ -4177,7 +4259,7 @@ std::string VulkanHppGenerator::constructCommandResultEnumerateTwoVectorsDepreca commandData, returnParamIndex, returnParamIndex, vectorParamIndices, !definition, withAllocators ); std::string commandName = determineCommandName( name, commandData.params[0].type.type ); std::string nodiscard = constructNoDiscardEnhanced( commandData ); - std::string returnType = determineEnhancedReturnType( commandData, returnParamIndex, vectorParamIndices, false ); + std::string returnType = determineEnhancedReturnType( commandData, returnParamIndex, false ); std::string templateType = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" ); if ( definition ) @@ -4406,7 +4488,7 @@ std::string std::string str; - auto firstVectorParamIt = vectorParamIndices.begin(); + auto firstVectorParamIt = vectorParamIndices.begin(); assert( commandData.params[0].type.type == commandData.handle ); @@ -4637,7 +4719,8 @@ std::string VulkanHppGenerator::constructCommandResultGetVector( std::string con std::map( { { "argumentList", argumentList }, { "callArguments", - constructCallArgumentsGetVector( commandData.params, { returnParamIndex }, vectorParamIndices, false ) }, + constructCallArgumentsGetVector( + commandData.handle, commandData.params, { returnParamIndex }, vectorParamIndices, false ) }, { "className", stripPrefix( commandData.handle, "Vk" ) }, { "commandName", commandName }, { "dataName", startLowerCase( stripPrefix( commandData.params[returnParamIndex].name, "p" ) ) }, @@ -4719,7 +4802,8 @@ std::string { "allocatorType", allocatorType }, { "argumentList", argumentList }, { "callArguments", - constructCallArgumentsGetVector( commandData.params, returnParamIndices, vectorParamIndices, false ) }, + constructCallArgumentsGetVector( + commandData.handle, commandData.params, returnParamIndices, vectorParamIndices, false ) }, { "className", stripPrefix( commandData.handle, "Vk" ) }, { "commandName", commandName }, { "nodiscard", nodiscard }, @@ -4831,7 +4915,7 @@ std::string std::string str; std::set skippedParams = - determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, returnParamIndex ); + determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, { returnParamIndex } ); std::string argumentList = constructArgumentListEnhanced( commandData.params, skippedParams, INVALID_INDEX, definition, withAllocator ); @@ -4863,7 +4947,8 @@ std::string std::map( { { "argumentList", argumentList }, { "callArguments", - constructCallArgumentsGetVector( commandData.params, { returnParamIndex }, vectorParamIndices, false ) }, + constructCallArgumentsGetVector( + commandData.handle, commandData.params, { returnParamIndex }, vectorParamIndices, false ) }, { "className", stripPrefix( commandData.handle, "Vk" ) }, { "commandName", commandName }, { "nodiscard", nodiscard }, @@ -4914,7 +4999,7 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesSingular std::string str; std::set skippedParams = - determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, returnParamIndex ); + determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, { returnParamIndex } ); size_t singularParam = ( returnParamIndex == vectorParamIndices.begin()->first ) ? std::next( vectorParamIndices.begin() )->first : vectorParamIndices.begin()->first; @@ -4944,7 +5029,8 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesSingular std::map( { { "argumentList", argumentList }, { "callArguments", - constructCallArgumentsGetVector( commandData.params, { returnParamIndex }, vectorParamIndices, true ) }, + constructCallArgumentsGetVector( + commandData.handle, commandData.params, { returnParamIndex }, vectorParamIndices, true ) }, { "className", stripPrefix( commandData.handle, "Vk" ) }, { "commandName", commandName }, { "nodiscard", nodiscard }, @@ -4984,7 +5070,7 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesUnique( std::string str; std::set skippedParams = - determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, returnParamIndex ); + determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, { returnParamIndex } ); std::string argumentList = constructArgumentListEnhanced( commandData.params, skippedParams, INVALID_INDEX, definition, withAllocator ); @@ -5052,7 +5138,8 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesUnique( std::map( { { "argumentList", argumentList }, { "callArguments", - constructCallArgumentsGetVector( commandData.params, { returnParamIndex }, vectorParamIndices, false ) }, + constructCallArgumentsGetVector( + commandData.handle, commandData.params, { returnParamIndex }, vectorParamIndices, false ) }, { "className", className }, { "commandName", commandName }, { "deleterDefinition", deleterDefinition }, @@ -5107,7 +5194,7 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesUniqueSi std::string str; std::set skippedParams = - determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, returnParamIndex ); + determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, { returnParamIndex } ); size_t singularParam = ( returnParamIndex == vectorParamIndices.begin()->first ) ? std::next( vectorParamIndices.begin() )->first : vectorParamIndices.begin()->first; @@ -5138,7 +5225,8 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesUniqueSi std::map( { { "argumentList", argumentList }, { "callArguments", - constructCallArgumentsGetVector( commandData.params, { returnParamIndex }, vectorParamIndices, true ) }, + constructCallArgumentsGetVector( + commandData.handle, commandData.params, { returnParamIndex }, vectorParamIndices, true ) }, { "className", stripPrefix( commandData.handle, "Vk" ) }, { "commandName", commandName }, { "handleName", @@ -5180,7 +5268,7 @@ std::string std::string argumentList = constructArgumentListEnhanced( commandData.params, - determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, returnParamIndex ), + determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, { returnParamIndex } ), INVALID_INDEX, definition, false ); @@ -5204,7 +5292,8 @@ std::string std::map( { { "argumentList", argumentList }, { "callArguments", - constructCallArgumentsGetVector( commandData.params, { returnParamIndex }, vectorParamIndices, true ) }, + constructCallArgumentsGetVector( + commandData.handle, commandData.params, { returnParamIndex }, vectorParamIndices, true ) }, { "className", stripPrefix( commandData.handle, "Vk" ) }, { "commandName", commandName }, { "dataName", startLowerCase( stripPrefix( commandData.params[returnParamIndex].name, "p" ) ) }, @@ -5532,9 +5621,11 @@ std::string VulkanHppGenerator::constructCommandVoidEnumerate( std::string const { "counterName", startLowerCase( stripPrefix( commandData.params[vectorParamIndex.second].name, "p" ) ) }, { "counterType", commandData.params[vectorParamIndex.second].type.type }, { "firstCallArguments", - constructCallArgumentsEnumerateVectors( commandData.params, { vectorParamIndex }, true ) }, + constructCallArgumentsEnumerateVectors( + commandData.handle, commandData.params, { vectorParamIndex }, true ) }, { "secondCallArguments", - constructCallArgumentsEnumerateVectors( commandData.params, { vectorParamIndex }, false ) }, + constructCallArgumentsEnumerateVectors( + commandData.handle, commandData.params, { vectorParamIndex }, false ) }, { "typenameCheck", withAllocators ? typenameCheck : "" }, { "vectorAllocator", withAllocators @@ -5769,9 +5860,7 @@ std::string vectorParamIndices, skippedParams.find( i ) != skippedParams.end(), argEncountered, - ( templateParamIndex == i ), - withDefaults, - withAllocator ); + ( templateParamIndex == i ) ); } if ( argEncountered ) @@ -7128,17 +7217,10 @@ size_t VulkanHppGenerator::determineDefaultStartIndex( std::vector co std::string VulkanHppGenerator::determineEnhancedReturnType( CommandData const & commandData, size_t returnParamIndex, - std::map const & vectorParamIndices, bool isStructureChain ) const { assert( ( returnParamIndex == INVALID_INDEX ) || ( returnParamIndex < commandData.params.size() ) ); -#if !defined( NDEBUG ) - for ( auto vpi : vectorParamIndices ) - { - assert( ( vpi.first != vpi.second ) && ( vpi.first < commandData.params.size() ) && - ( ( vpi.second == INVALID_INDEX ) || ( vpi.second < commandData.params.size() ) ) ); - } -#endif + std::string enhancedReturnType; if ( returnParamIndex != INVALID_INDEX ) { @@ -7146,24 +7228,13 @@ std::string VulkanHppGenerator::determineEnhancedReturnType( CommandData const & // -> we can return that parameter assert( ( commandData.returnType == "void" ) || ( commandData.returnType == "VkResult" ) ); assert( commandData.successCodes.empty() || ( commandData.successCodes[0] == "VK_SUCCESS" ) ); - if ( vectorParamIndices.find( returnParamIndex ) != vectorParamIndices.end() ) - { - enhancedReturnType = ( commandData.params[returnParamIndex].type.type == "void" ) - ? "std::vector" // the return parameter is a vector-type parameter - : isStructureChain - ? "std::vector" // for structureChain returns, it's just - // a vector of StrutureChains - : "std::vector<" + stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" ) + - ",Allocator>"; // for the other parameters, we use a vector of the pure type - } - else - { - // it's a simple parameter -> get the type and just remove the trailing '*' (originally, it's a pointer) - assert( commandData.params[returnParamIndex].type.postfix.back() == '*' ); - assert( ( commandData.params[returnParamIndex].type.prefix.find( "const" ) == std::string::npos ) && - ( commandData.params[returnParamIndex].type.postfix.find( "const" ) == std::string::npos ) ); - enhancedReturnType = stripPostfix( commandData.params[returnParamIndex].type.compose(), "*" ); - } + enhancedReturnType = ( commandData.params[returnParamIndex].type.type == "void" ) + ? "std::vector" // the return parameter is a vector-type parameter + : isStructureChain + ? "std::vector" // for structureChain returns, it's just + // a vector of StrutureChains + : "std::vector<" + stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" ) + + ",Allocator>"; // for the other parameters, we use a vector of the pure type } else if ( ( commandData.returnType == "VkResult" ) && ( commandData.successCodes.size() == 1 ) ) { @@ -7225,9 +7296,9 @@ size_t VulkanHppGenerator::determineReturnParamIndex( CommandData const & std::set VulkanHppGenerator::determineSkippedParams( std::string const & handleType, std::vector const & params, std::map const & vectorParamIndices, - size_t returnParamIndex ) const + std::vector const & returnParamIndices ) const { - std::set skippedParams = { returnParamIndex }; + std::set skippedParams = { returnParamIndices.begin(), returnParamIndices.end() }; if ( !handleType.empty() ) { @@ -7236,7 +7307,10 @@ std::set VulkanHppGenerator::determineSkippedParams( std::string const & for ( auto const & vpi : vectorParamIndices ) { - if ( ( vpi.first != returnParamIndex ) || params[vpi.second].type.isValue() ) + if ( ( std::find_if( returnParamIndices.begin(), + returnParamIndices.end(), + [&vpi]( size_t rpi ) { return vpi.first == rpi; } ) == returnParamIndices.end() ) || + params[vpi.second].type.isValue() ) { skippedParams.insert( vpi.second ); } diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index a1c12e3..19f2767 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -289,7 +289,6 @@ private: size_t templateParamIndex, bool twoStep, bool firstCall ) const; - void appendArgumentVulkanType( std::string & str, ParamData const & paramData ) const; void appendBitmask( std::string & os, std::string const & bitmaskName, std::string const & bitmaskType, @@ -442,9 +441,7 @@ private: std::map const & vectorParamIndices, bool skip, bool argEncountered, - bool isTemplateParam, - bool withDefaults, - bool withAllocator ) const; + bool isTemplateParam ) const; void appendFunctionHeaderArgumentEnhancedPointer( std::string & str, ParamData const & param, std::string const & strippedParameterName ) const; @@ -452,9 +449,7 @@ private: ParamData const & param, std::string const & strippedParameterName, bool hasSizeParam, - bool isTemplateParam, - bool withDefaults, - bool withAllocator ) const; + bool isTemplateParam ) const; void appendFunctionHeaderArguments( std::string & str, CommandData const & commandData, size_t returnParamIndex, @@ -521,13 +516,15 @@ private: std::set const & skippedParams, bool definition ) const; std::string constructCallArgument( ParamData const & param, bool enhanced ) const; - std::string constructCallArgumentsEnumerateVectors( std::vector const & params, + std::string constructCallArgumentsEnumerateVectors( std::string const & handle, + std::vector const & params, std::map const & vectorParamIndices, bool vectorAsNullptr ) const; std::string constructCallArgumentsGetValue( std::string const & handle, std::vector const & params, size_t skippedParams ) const; - std::string constructCallArgumentsGetVector( std::vector const & params, + std::string constructCallArgumentsGetVector( std::string const & handle, + std::vector const & params, std::vector const & returnParamIndex, std::map const & vectorParamIndices, bool singular ) const; @@ -538,6 +535,11 @@ private: CommandData const & commandData, bool definition, std::map const & vectorParamIndices ) const; + std::string constructCommandResultEnumerate( std::string const & name, + CommandData const & commandData, + bool definition, + std::pair const & vectorParamIndices, + bool withAllocators ) const; std::string constructCommandResultEnumerateTwoVectors( std::string const & name, CommandData const & commandData, bool definition, @@ -679,7 +681,6 @@ private: std::set const & skippedParams ) const; std::string determineEnhancedReturnType( CommandData const & commandData, size_t returnParamIndex, - std::map const & vectorParamIndices, bool isStructureChain ) const; size_t determineReturnParamIndex( CommandData const & commandData, std::map const & vectorParamIndices, @@ -687,7 +688,7 @@ private: std::set determineSkippedParams( std::string const & handleType, std::vector const & params, std::map const & vectorParamIndices, - size_t returnParamIndex ) const; + std::vector const & returnParamIndex ) const; std::string determineSubStruct( std::pair const & structure ) const; size_t determineTemplateParamIndex( std::vector const & params, std::map const & vectorParamIndices ) const; diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index c99125c..224917d 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -55052,24 +55052,26 @@ namespace VULKAN_HPP_NAMESPACE template VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE( - VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, - uint32_t * pPresentationTimingCount, - VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings, + VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, + uint32_t * pPresentationTimingCount, + VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template < - typename Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + typename PastPresentationTimingGOOGLEAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = PastPresentationTimingGOOGLEAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, - Allocator const & vectorAllocator, + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, + PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -55108,76 +55110,87 @@ namespace VULKAN_HPP_NAMESPACE template VULKAN_HPP_NODISCARD Result getPipelineExecutableInternalRepresentationsKHR( - const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo, - uint32_t * pInternalRepresentationCount, - VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations, + const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo, + uint32_t * pInternalRepresentationCount, + VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations + VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> VULKAN_HPP_NODISCARD - typename ResultValueType>::type + typename ResultValueType>::type getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template < - typename Allocator = std::allocator, + typename PipelineExecutableInternalRepresentationKHRAllocator = + std::allocator, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + typename B = PipelineExecutableInternalRepresentationKHRAllocator, typename std::enable_if::value, int>::type = 0> VULKAN_HPP_NODISCARD - typename ResultValueType>::type - getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, - Allocator const & vectorAllocator, - Dispatch const & d - VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + typename ResultValueType>::type + getPipelineExecutableInternalRepresentationsKHR( + const PipelineExecutableInfoKHR & executableInfo, + PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR( - const VULKAN_HPP_NAMESPACE::PipelineInfoKHR * pPipelineInfo, - uint32_t * pExecutableCount, - VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties, + const VULKAN_HPP_NAMESPACE::PipelineInfoKHR * pPipelineInfo, + uint32_t * pExecutableCount, + VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType< + std::vector>::type getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = PipelineExecutablePropertiesKHRAllocator, typename std::enable_if::value, - int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, - Allocator const & vectorAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + int>::type = 0> + VULKAN_HPP_NODISCARD typename ResultValueType< + std::vector>::type + getPipelineExecutablePropertiesKHR( + const PipelineInfoKHR & pipelineInfo, + PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR( - const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo, - uint32_t * pStatisticCount, - VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR * pStatistics, + const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo, + uint32_t * pStatisticCount, + VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR * pStatistics VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType< + std::vector>::type getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = PipelineExecutableStatisticKHRAllocator, typename std::enable_if::value, - int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, - Allocator const & vectorAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + int>::type = 0> + VULKAN_HPP_NODISCARD typename ResultValueType< + std::vector>::type + getPipelineExecutableStatisticsKHR( + const PipelineExecutableInfoKHR & executableInfo, + PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -60699,44 +60712,44 @@ namespace VULKAN_HPP_NAMESPACE template VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties( - const char * pLayerName, - uint32_t * pPropertyCount, - VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + const char * pLayerName, + uint32_t * pPropertyCount, + VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateDeviceExtensionProperties( Optional layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = ExtensionPropertiesAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumerateDeviceExtensionProperties( Optional layerName, - Allocator const & vectorAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumerateDeviceExtensionProperties( Optional layerName, + ExtensionPropertiesAllocator & extensionPropertiesAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties( - uint32_t * pPropertyCount, - VULKAN_HPP_NAMESPACE::LayerProperties * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + uint32_t * pPropertyCount, + VULKAN_HPP_NAMESPACE::LayerProperties * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = LayerPropertiesAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumerateDeviceLayerProperties( Allocator const & vectorAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -60794,48 +60807,52 @@ namespace VULKAN_HPP_NAMESPACE template VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR( - VULKAN_HPP_NAMESPACE::DisplayKHR display, - uint32_t * pPropertyCount, - VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties, + VULKAN_HPP_NAMESPACE::DisplayKHR display, + uint32_t * pPropertyCount, + VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template < - typename Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + typename DisplayModeProperties2KHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = DisplayModeProperties2KHRAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, - Allocator const & vectorAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, + DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR( - VULKAN_HPP_NAMESPACE::DisplayKHR display, - uint32_t * pPropertyCount, - VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties, + VULKAN_HPP_NAMESPACE::DisplayKHR display, + uint32_t * pPropertyCount, + VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template < - typename Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + typename DisplayModePropertiesKHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = DisplayModePropertiesKHRAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, - Allocator const & vectorAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, + DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -60889,40 +60906,42 @@ namespace VULKAN_HPP_NAMESPACE template VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT( - uint32_t * pTimeDomainCount, - VULKAN_HPP_NAMESPACE::TimeDomainEXT * pTimeDomains, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + uint32_t * pTimeDomainCount, + VULKAN_HPP_NAMESPACE::TimeDomainEXT * pTimeDomains VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = TimeDomainEXTAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCalibrateableTimeDomainsEXT( Allocator const & vectorAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCalibrateableTimeDomainsEXT( TimeDomainEXTAllocator & timeDomainEXTAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV( - uint32_t * pPropertyCount, - VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties, + uint32_t * pPropertyCount, + VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = CooperativeMatrixPropertiesNVAllocator, typename std::enable_if::value, - int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCooperativeMatrixPropertiesNV( Allocator const & vectorAllocator, + int>::type = 0> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -60943,81 +60962,89 @@ namespace VULKAN_HPP_NAMESPACE template VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR( - uint32_t * pPropertyCount, - VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties, + uint32_t * pPropertyCount, + VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template < - typename Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + typename DisplayPlaneProperties2KHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = DisplayPlaneProperties2KHRAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayPlaneProperties2KHR( Allocator const & vectorAllocator, + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR( - uint32_t * pPropertyCount, - VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties, + uint32_t * pPropertyCount, + VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template < - typename Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + typename DisplayPlanePropertiesKHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = DisplayPlanePropertiesKHRAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayPlanePropertiesKHR( Allocator const & vectorAllocator, + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_NODISCARD Result - getDisplayProperties2KHR( uint32_t * pPropertyCount, - VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR( + uint32_t * pPropertyCount, + VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; template < - typename Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + typename DisplayProperties2KHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = DisplayProperties2KHRAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayProperties2KHR( Allocator const & vectorAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_NODISCARD Result - getDisplayPropertiesKHR( uint32_t * pPropertyCount, - VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR( + uint32_t * pPropertyCount, + VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = DisplayPropertiesKHRAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayPropertiesKHR( Allocator const & vectorAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -61193,22 +61220,28 @@ namespace VULKAN_HPP_NAMESPACE template VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR( - uint32_t * pFragmentShadingRateCount, - VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates, + uint32_t * pFragmentShadingRateCount, + VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates + VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template < + typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType< + std::vector>::type getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, - typename std::enable_if::value, - int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getFragmentShadingRatesKHR( Allocator const & vectorAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + template < + typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = PhysicalDeviceFragmentShadingRateKHRAllocator, + typename std::enable_if::value, + int>::type = 0> + VULKAN_HPP_NODISCARD typename ResultValueType< + std::vector>::type + getFragmentShadingRatesKHR( + PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -61311,22 +61344,22 @@ namespace VULKAN_HPP_NAMESPACE template VULKAN_HPP_NODISCARD Result - getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, - uint32_t * pRectCount, - VULKAN_HPP_NAMESPACE::Rect2D * pRects, + getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, + uint32_t * pRectCount, + VULKAN_HPP_NAMESPACE::Rect2D * pRects VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = Rect2DAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + VULKAN_HPP_NODISCARD typename ResultValueType>::type getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, - Allocator const & vectorAllocator, + Rect2DAllocator & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -61544,23 +61577,28 @@ namespace VULKAN_HPP_NAMESPACE template VULKAN_HPP_NODISCARD Result getSupportedFramebufferMixedSamplesCombinationsNV( - uint32_t * pCombinationCount, - VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations, + uint32_t * pCombinationCount, + VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template < + typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType< + std::vector>::type getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, - typename std::enable_if::value, - int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template < + typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = FramebufferMixedSamplesCombinationNVAllocator, + typename std::enable_if::value, + int>::type = 0> + VULKAN_HPP_NODISCARD typename ResultValueType< + std::vector>::type getSupportedFramebufferMixedSamplesCombinationsNV( - Allocator const & vectorAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -61606,46 +61644,46 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_NODISCARD Result - getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, - uint32_t * pSurfaceFormatCount, - VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR * pSurfaceFormats, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR( + const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, + uint32_t * pSurfaceFormatCount, + VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR * pSurfaceFormats VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = SurfaceFormat2KHRAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, - Allocator const & vectorAllocator, + SurfaceFormat2KHRAllocator & surfaceFormat2KHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_NODISCARD Result - getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, - uint32_t * pSurfaceFormatCount, - VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR( + VULKAN_HPP_NAMESPACE::SurfaceKHR surface, + uint32_t * pSurfaceFormatCount, + VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = SurfaceFormatKHRAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, - Allocator const & vectorAllocator, + SurfaceFormatKHRAllocator & surfaceFormatKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -61654,44 +61692,44 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, uint32_t * pPresentModeCount, - VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes, + VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = PresentModeKHRAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, - Allocator const & vectorAllocator, + PresentModeKHRAllocator & presentModeKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_WIN32_KHR*/ template VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR( - VULKAN_HPP_NAMESPACE::SurfaceKHR surface, - uint32_t * pPresentModeCount, - VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NAMESPACE::SurfaceKHR surface, + uint32_t * pPresentModeCount, + VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = PresentModeKHRAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, - Allocator const & vectorAllocator, + PresentModeKHRAllocator & presentModeKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -61710,23 +61748,25 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_NODISCARD Result - getToolPropertiesEXT( uint32_t * pToolCount, - VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT * pToolProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NODISCARD Result getToolPropertiesEXT( + uint32_t * pToolCount, + VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT * pToolProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType< + std::vector>::type getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = PhysicalDeviceToolPropertiesEXTAllocator, typename std::enable_if::value, - int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getToolPropertiesEXT( Allocator const & vectorAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + int>::type = 0> + VULKAN_HPP_NODISCARD typename ResultValueType< + std::vector>::type + getToolPropertiesEXT( PhysicalDeviceToolPropertiesEXTAllocator & physicalDeviceToolPropertiesEXTAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #ifdef VK_USE_PLATFORM_WAYLAND_KHR @@ -90087,41 +90127,47 @@ namespace VULKAN_HPP_NAMESPACE template VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups( - uint32_t * pPhysicalDeviceGroupCount, - VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, + uint32_t * pPhysicalDeviceGroupCount, + VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties + VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = PhysicalDeviceGroupPropertiesAllocator, typename std::enable_if::value, - int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumeratePhysicalDeviceGroups( Allocator const & vectorAllocator, + int>::type = 0> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( - uint32_t * pPhysicalDeviceGroupCount, - VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, + uint32_t * pPhysicalDeviceGroupCount, + VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties + VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = PhysicalDeviceGroupPropertiesAllocator, typename std::enable_if::value, - int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumeratePhysicalDeviceGroupsKHR( Allocator const & vectorAllocator, + int>::type = 0> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -90250,44 +90296,44 @@ namespace VULKAN_HPP_NAMESPACE template VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties( - const char * pLayerName, - uint32_t * pPropertyCount, - VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT; + const char * pLayerName, + uint32_t * pPropertyCount, + VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateInstanceExtensionProperties( Optional layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = ExtensionPropertiesAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumerateInstanceExtensionProperties( Optional layerName, - Allocator const & vectorAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumerateInstanceExtensionProperties( Optional layerName, + ExtensionPropertiesAllocator & extensionPropertiesAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template - VULKAN_HPP_NODISCARD Result - enumerateInstanceLayerProperties( uint32_t * pPropertyCount, - VULKAN_HPP_NAMESPACE::LayerProperties * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT; + VULKAN_HPP_NODISCARD Result enumerateInstanceLayerProperties( + uint32_t * pPropertyCount, + VULKAN_HPP_NAMESPACE::LayerProperties * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> - VULKAN_HPP_NODISCARD typename ResultValueType>::type + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename B = Allocator, + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B = LayerPropertiesAllocator, typename std::enable_if::value, int>::type = 0> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumerateInstanceLayerProperties( Allocator const & vectorAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -90359,14 +90405,16 @@ namespace VULKAN_HPP_NAMESPACE return static_cast( d.vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast( pProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - enumerateInstanceExtensionProperties( Optional layerName, Dispatch const & d ) + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + enumerateInstanceExtensionProperties( Optional layerName, Dispatch const & d ) { - std::vector properties; - uint32_t propertyCount; - Result result; + std::vector properties; + uint32_t propertyCount; + Result result; do { result = static_cast( @@ -90378,28 +90426,30 @@ namespace VULKAN_HPP_NAMESPACE d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceExtensionProperties" ); } - template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - enumerateInstanceExtensionProperties( Optional layerName, - Allocator const & vectorAllocator, - Dispatch const & d ) + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + enumerateInstanceExtensionProperties( Optional layerName, + ExtensionPropertiesAllocator & extensionPropertiesAllocator, + Dispatch const & d ) { - std::vector properties( vectorAllocator ); - uint32_t propertyCount; - Result result; + std::vector properties( extensionPropertiesAllocator ); + uint32_t propertyCount; + Result result; do { result = static_cast( @@ -90411,11 +90461,11 @@ namespace VULKAN_HPP_NAMESPACE d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( @@ -90432,14 +90482,16 @@ namespace VULKAN_HPP_NAMESPACE return static_cast( d.vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast( pProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - enumerateInstanceLayerProperties( Dispatch const & d ) + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + enumerateInstanceLayerProperties( Dispatch const & d ) { - std::vector properties; - uint32_t propertyCount; - Result result; + std::vector properties; + uint32_t propertyCount; + Result result; do { result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); @@ -90448,25 +90500,27 @@ namespace VULKAN_HPP_NAMESPACE properties.resize( propertyCount ); result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceLayerProperties" ); } - template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - enumerateInstanceLayerProperties( Allocator const & vectorAllocator, Dispatch const & d ) + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d ) { - std::vector properties( vectorAllocator ); - uint32_t propertyCount; - Result result; + std::vector properties( layerPropertiesAllocator ); + uint32_t propertyCount; + Result result; do { result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); @@ -90475,11 +90529,11 @@ namespace VULKAN_HPP_NAMESPACE properties.resize( propertyCount ); result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceLayerProperties" ); @@ -99637,15 +99691,16 @@ namespace VULKAN_HPP_NAMESPACE pPresentationTimingCount, reinterpret_cast( pPresentationTimings ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template + template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type + typename ResultValueType>::type Device::getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d ) const { - std::vector presentationTimings; - uint32_t presentationTimingCount; - Result result; + std::vector presentationTimings; + uint32_t presentationTimingCount; + Result result; do { result = static_cast( d.vkGetPastPresentationTimingGOOGLE( @@ -99658,30 +99713,33 @@ namespace VULKAN_HPP_NAMESPACE static_cast( swapchain ), &presentationTimingCount, reinterpret_cast( presentationTimings.data() ) ) ); + VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( presentationTimingCount < presentationTimings.size() ) ) { - VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); presentationTimings.resize( presentationTimingCount ); } return createResultValue( result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" ); } + template < - typename Allocator, + typename PastPresentationTimingGOOGLEAllocator, typename Dispatch, typename B, typename std::enable_if::value, int>::type> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - Device::getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, - Allocator const & vectorAllocator, - Dispatch const & d ) const + typename ResultValueType>::type + Device::getPastPresentationTimingGOOGLE( + VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, + PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator, + Dispatch const & d ) const { - std::vector presentationTimings( vectorAllocator ); - uint32_t presentationTimingCount; - Result result; + std::vector presentationTimings( + pastPresentationTimingGOOGLEAllocator ); + uint32_t presentationTimingCount; + Result result; do { result = static_cast( d.vkGetPastPresentationTimingGOOGLE( @@ -99694,11 +99752,11 @@ namespace VULKAN_HPP_NAMESPACE static_cast( swapchain ), &presentationTimingCount, reinterpret_cast( presentationTimings.data() ) ) ); + VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( presentationTimingCount < presentationTimings.size() ) ) { - VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); presentationTimings.resize( presentationTimingCount ); } return createResultValue( @@ -99819,16 +99877,19 @@ namespace VULKAN_HPP_NAMESPACE pInternalRepresentationCount, reinterpret_cast( pInternalRepresentations ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template + template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type + typename ResultValueType>::type Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const & d ) const { - std::vector internalRepresentations; - uint32_t internalRepresentationCount; - Result result; + std::vector + internalRepresentations; + uint32_t internalRepresentationCount; + Result result; do { result = static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( @@ -99844,32 +99905,36 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &executableInfo ), &internalRepresentationCount, reinterpret_cast( internalRepresentations.data() ) ) ); + VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( internalRepresentationCount < internalRepresentations.size() ) ) { - VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); internalRepresentations.resize( internalRepresentationCount ); } return createResultValue( result, internalRepresentations, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" ); } + template < - typename Allocator, + typename PipelineExecutableInternalRepresentationKHRAllocator, typename Dispatch, typename B, typename std::enable_if::value, int>::type> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, - Allocator const & vectorAllocator, - Dispatch const & d ) const + typename ResultValueType>::type + Device::getPipelineExecutableInternalRepresentationsKHR( + const PipelineExecutableInfoKHR & executableInfo, + PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator, + Dispatch const & d ) const { - std::vector internalRepresentations( vectorAllocator ); - uint32_t internalRepresentationCount; - Result result; + std::vector + internalRepresentations( pipelineExecutableInternalRepresentationKHRAllocator ); + uint32_t internalRepresentationCount; + Result result; do { result = static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( @@ -99885,11 +99950,11 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &executableInfo ), &internalRepresentationCount, reinterpret_cast( internalRepresentations.data() ) ) ); + VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( internalRepresentationCount < internalRepresentations.size() ) ) { - VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); internalRepresentations.resize( internalRepresentationCount ); } return createResultValue( result, @@ -99911,15 +99976,16 @@ namespace VULKAN_HPP_NAMESPACE pExecutableCount, reinterpret_cast( pProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< + std::vector>::type Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const & d ) const { - std::vector properties; - uint32_t executableCount; - Result result; + std::vector properties; + uint32_t executableCount; + Result result; do { result = static_cast( d.vkGetPipelineExecutablePropertiesKHR( @@ -99932,30 +99998,33 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &pipelineInfo ), &executableCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( executableCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( executableCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( executableCount <= properties.size() ); properties.resize( executableCount ); } return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" ); } + template < - typename Allocator, + typename PipelineExecutablePropertiesKHRAllocator, typename Dispatch, typename B, typename std::enable_if::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, - Allocator const & vectorAllocator, - Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< + std::vector>::type + Device::getPipelineExecutablePropertiesKHR( + const PipelineInfoKHR & pipelineInfo, + PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator, + Dispatch const & d ) const { - std::vector properties( vectorAllocator ); - uint32_t executableCount; - Result result; + std::vector properties( + pipelineExecutablePropertiesKHRAllocator ); + uint32_t executableCount; + Result result; do { result = static_cast( d.vkGetPipelineExecutablePropertiesKHR( @@ -99968,11 +100037,11 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &pipelineInfo ), &executableCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( executableCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( executableCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( executableCount <= properties.size() ); properties.resize( executableCount ); } return createResultValue( @@ -99993,16 +100062,17 @@ namespace VULKAN_HPP_NAMESPACE pStatisticCount, reinterpret_cast( pStatistics ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template + template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type + typename ResultValueType>::type Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const & d ) const { - std::vector statistics; - uint32_t statisticCount; - Result result; + std::vector statistics; + uint32_t statisticCount; + Result result; do { result = static_cast( d.vkGetPipelineExecutableStatisticsKHR( @@ -100018,30 +100088,33 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &executableInfo ), &statisticCount, reinterpret_cast( statistics.data() ) ) ); + VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( statisticCount < statistics.size() ) ) { - VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); statistics.resize( statisticCount ); } return createResultValue( result, statistics, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" ); } + template < - typename Allocator, + typename PipelineExecutableStatisticKHRAllocator, typename Dispatch, typename B, typename std::enable_if::value, int>::type> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, - Allocator const & vectorAllocator, - Dispatch const & d ) const + typename ResultValueType>::type + Device::getPipelineExecutableStatisticsKHR( + const PipelineExecutableInfoKHR & executableInfo, + PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator, + Dispatch const & d ) const { - std::vector statistics( vectorAllocator ); - uint32_t statisticCount; - Result result; + std::vector statistics( + pipelineExecutableStatisticKHRAllocator ); + uint32_t statisticCount; + Result result; do { result = static_cast( d.vkGetPipelineExecutableStatisticsKHR( @@ -100057,11 +100130,11 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &executableInfo ), &statisticCount, reinterpret_cast( statistics.data() ) ) ); + VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( statisticCount < statistics.size() ) ) { - VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); statistics.resize( statisticCount ); } return createResultValue( @@ -102836,15 +102909,16 @@ namespace VULKAN_HPP_NAMESPACE pPhysicalDeviceGroupCount, reinterpret_cast( pPhysicalDeviceGroupProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template + template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type + typename ResultValueType>::type Instance::enumeratePhysicalDeviceGroups( Dispatch const & d ) const { - std::vector physicalDeviceGroupProperties; - uint32_t physicalDeviceGroupCount; - Result result; + std::vector physicalDeviceGroupProperties; + uint32_t physicalDeviceGroupCount; + Result result; do { result = @@ -102856,28 +102930,31 @@ namespace VULKAN_HPP_NAMESPACE m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); + VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) ) { - VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); } return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" ); } + template < - typename Allocator, + typename PhysicalDeviceGroupPropertiesAllocator, typename Dispatch, typename B, typename std::enable_if::value, int>::type> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - Instance::enumeratePhysicalDeviceGroups( Allocator const & vectorAllocator, Dispatch const & d ) const + typename ResultValueType>::type + Instance::enumeratePhysicalDeviceGroups( + PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const { - std::vector physicalDeviceGroupProperties( vectorAllocator ); - uint32_t physicalDeviceGroupCount; - Result result; + std::vector physicalDeviceGroupProperties( + physicalDeviceGroupPropertiesAllocator ); + uint32_t physicalDeviceGroupCount; + Result result; do { result = @@ -102889,11 +102966,11 @@ namespace VULKAN_HPP_NAMESPACE m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); + VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) ) { - VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); } return createResultValue( @@ -102912,15 +102989,16 @@ namespace VULKAN_HPP_NAMESPACE pPhysicalDeviceGroupCount, reinterpret_cast( pPhysicalDeviceGroupProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template + template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type + typename ResultValueType>::type Instance::enumeratePhysicalDeviceGroupsKHR( Dispatch const & d ) const { - std::vector physicalDeviceGroupProperties; - uint32_t physicalDeviceGroupCount; - Result result; + std::vector physicalDeviceGroupProperties; + uint32_t physicalDeviceGroupCount; + Result result; do { result = @@ -102932,29 +103010,32 @@ namespace VULKAN_HPP_NAMESPACE m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); + VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) ) { - VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); } return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" ); } + template < - typename Allocator, + typename PhysicalDeviceGroupPropertiesAllocator, typename Dispatch, typename B, typename std::enable_if::value, int>::type> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - Instance::enumeratePhysicalDeviceGroupsKHR( Allocator const & vectorAllocator, Dispatch const & d ) const + typename ResultValueType>::type + Instance::enumeratePhysicalDeviceGroupsKHR( + PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const { - std::vector physicalDeviceGroupProperties( vectorAllocator ); - uint32_t physicalDeviceGroupCount; - Result result; + std::vector physicalDeviceGroupProperties( + physicalDeviceGroupPropertiesAllocator ); + uint32_t physicalDeviceGroupCount; + Result result; do { result = @@ -102966,11 +103047,11 @@ namespace VULKAN_HPP_NAMESPACE m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); + VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) ) { - VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); } return createResultValue( result, @@ -103233,15 +103314,17 @@ namespace VULKAN_HPP_NAMESPACE return static_cast( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast( pProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName, + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName, Dispatch const & d ) const { - std::vector properties; - uint32_t propertyCount; - Result result; + std::vector properties; + uint32_t propertyCount; + Result result; do { result = static_cast( d.vkEnumerateDeviceExtensionProperties( @@ -103254,28 +103337,30 @@ namespace VULKAN_HPP_NAMESPACE layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" ); } - template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName, - Allocator const & vectorAllocator, - Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName, + ExtensionPropertiesAllocator & extensionPropertiesAllocator, + Dispatch const & d ) const { - std::vector properties( vectorAllocator ); - uint32_t propertyCount; - Result result; + std::vector properties( extensionPropertiesAllocator ); + uint32_t propertyCount; + Result result; do { result = static_cast( d.vkEnumerateDeviceExtensionProperties( @@ -103288,11 +103373,11 @@ namespace VULKAN_HPP_NAMESPACE layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( @@ -103309,14 +103394,16 @@ namespace VULKAN_HPP_NAMESPACE return static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::enumerateDeviceLayerProperties( Dispatch const & d ) const + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::enumerateDeviceLayerProperties( Dispatch const & d ) const { - std::vector properties; - uint32_t propertyCount; - Result result; + std::vector properties; + uint32_t propertyCount; + Result result; do { result = static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) ); @@ -103325,26 +103412,29 @@ namespace VULKAN_HPP_NAMESPACE properties.resize( propertyCount ); result = static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" ); } - template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::enumerateDeviceLayerProperties( Allocator const & vectorAllocator, Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, + Dispatch const & d ) const { - std::vector properties( vectorAllocator ); - uint32_t propertyCount; - Result result; + std::vector properties( layerPropertiesAllocator ); + uint32_t propertyCount; + Result result; do { result = static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) ); @@ -103353,11 +103443,11 @@ namespace VULKAN_HPP_NAMESPACE properties.resize( propertyCount ); result = static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( @@ -103581,15 +103671,16 @@ namespace VULKAN_HPP_NAMESPACE pPropertyCount, reinterpret_cast( pProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template + template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type + typename ResultValueType>::type PhysicalDevice::getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const { - std::vector properties; - uint32_t propertyCount; - Result result; + std::vector properties; + uint32_t propertyCount; + Result result; do { result = static_cast( d.vkGetDisplayModeProperties2KHR( @@ -103602,29 +103693,32 @@ namespace VULKAN_HPP_NAMESPACE static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" ); } - template ::value, int>::type> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, - Allocator const & vectorAllocator, - Dispatch const & d ) const + typename ResultValueType>::type + PhysicalDevice::getDisplayModeProperties2KHR( + VULKAN_HPP_NAMESPACE::DisplayKHR display, + DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator, + Dispatch const & d ) const { - std::vector properties( vectorAllocator ); - uint32_t propertyCount; - Result result; + std::vector properties( + displayModeProperties2KHRAllocator ); + uint32_t propertyCount; + Result result; do { result = static_cast( d.vkGetDisplayModeProperties2KHR( @@ -103637,11 +103731,11 @@ namespace VULKAN_HPP_NAMESPACE static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( @@ -103662,15 +103756,16 @@ namespace VULKAN_HPP_NAMESPACE pPropertyCount, reinterpret_cast( pProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template + template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type + typename ResultValueType>::type PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d ) const { - std::vector properties; - uint32_t propertyCount; - Result result; + std::vector properties; + uint32_t propertyCount; + Result result; do { result = static_cast( d.vkGetDisplayModePropertiesKHR( @@ -103683,29 +103778,31 @@ namespace VULKAN_HPP_NAMESPACE static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModePropertiesKHR" ); } - template ::value, int>::type> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, - Allocator const & vectorAllocator, - Dispatch const & d ) const + typename ResultValueType>::type + PhysicalDevice::getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, + DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator, + Dispatch const & d ) const { - std::vector properties( vectorAllocator ); - uint32_t propertyCount; - Result result; + std::vector properties( + displayModePropertiesKHRAllocator ); + uint32_t propertyCount; + Result result; do { result = static_cast( d.vkGetDisplayModePropertiesKHR( @@ -103718,11 +103815,11 @@ namespace VULKAN_HPP_NAMESPACE static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( @@ -103871,14 +103968,16 @@ namespace VULKAN_HPP_NAMESPACE return static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, pTimeDomainCount, reinterpret_cast( pTimeDomains ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCalibrateableTimeDomainsEXT( Dispatch const & d ) const + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getCalibrateableTimeDomainsEXT( Dispatch const & d ) const { - std::vector timeDomains; - uint32_t timeDomainCount; - Result result; + std::vector timeDomains; + uint32_t timeDomainCount; + Result result; do { result = static_cast( @@ -103888,26 +103987,29 @@ namespace VULKAN_HPP_NAMESPACE timeDomains.resize( timeDomainCount ); result = static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); + VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( timeDomainCount < timeDomains.size() ) ) { - VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); timeDomains.resize( timeDomainCount ); } return createResultValue( result, timeDomains, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); } - template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCalibrateableTimeDomainsEXT( Allocator const & vectorAllocator, Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getCalibrateableTimeDomainsEXT( TimeDomainEXTAllocator & timeDomainEXTAllocator, + Dispatch const & d ) const { - std::vector timeDomains( vectorAllocator ); - uint32_t timeDomainCount; - Result result; + std::vector timeDomains( timeDomainEXTAllocator ); + uint32_t timeDomainCount; + Result result; do { result = static_cast( @@ -103917,11 +104019,11 @@ namespace VULKAN_HPP_NAMESPACE timeDomains.resize( timeDomainCount ); result = static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); + VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( timeDomainCount < timeDomains.size() ) ) { - VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); timeDomains.resize( timeDomainCount ); } return createResultValue( @@ -103938,15 +104040,16 @@ namespace VULKAN_HPP_NAMESPACE return static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template + template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type + typename ResultValueType>::type PhysicalDevice::getCooperativeMatrixPropertiesNV( Dispatch const & d ) const { - std::vector properties; - uint32_t propertyCount; - Result result; + std::vector properties; + uint32_t propertyCount; + Result result; do { result = static_cast( @@ -103958,28 +104061,31 @@ namespace VULKAN_HPP_NAMESPACE m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" ); } + template < - typename Allocator, + typename CooperativeMatrixPropertiesNVAllocator, typename Dispatch, typename B, typename std::enable_if::value, int>::type> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getCooperativeMatrixPropertiesNV( Allocator const & vectorAllocator, Dispatch const & d ) const + typename ResultValueType>::type + PhysicalDevice::getCooperativeMatrixPropertiesNV( + CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator, Dispatch const & d ) const { - std::vector properties( vectorAllocator ); - uint32_t propertyCount; - Result result; + std::vector properties( + cooperativeMatrixPropertiesNVAllocator ); + uint32_t propertyCount; + Result result; do { result = static_cast( @@ -103991,11 +104097,11 @@ namespace VULKAN_HPP_NAMESPACE m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( @@ -104030,15 +104136,16 @@ namespace VULKAN_HPP_NAMESPACE return static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template + template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type + typename ResultValueType>::type PhysicalDevice::getDisplayPlaneProperties2KHR( Dispatch const & d ) const { - std::vector properties; - uint32_t propertyCount; - Result result; + std::vector properties; + uint32_t propertyCount; + Result result; do { result = static_cast( @@ -104048,27 +104155,30 @@ namespace VULKAN_HPP_NAMESPACE properties.resize( propertyCount ); result = static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" ); } - template ::value, int>::type> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getDisplayPlaneProperties2KHR( Allocator const & vectorAllocator, Dispatch const & d ) const + typename ResultValueType>::type + PhysicalDevice::getDisplayPlaneProperties2KHR( + DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator, Dispatch const & d ) const { - std::vector properties( vectorAllocator ); - uint32_t propertyCount; - Result result; + std::vector properties( + displayPlaneProperties2KHRAllocator ); + uint32_t propertyCount; + Result result; do { result = static_cast( @@ -104078,11 +104188,11 @@ namespace VULKAN_HPP_NAMESPACE properties.resize( propertyCount ); result = static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( @@ -104099,15 +104209,16 @@ namespace VULKAN_HPP_NAMESPACE return static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template + template VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type + typename ResultValueType>::type PhysicalDevice::getDisplayPlanePropertiesKHR( Dispatch const & d ) const { - std::vector properties; - uint32_t propertyCount; - Result result; + std::vector properties; + uint32_t propertyCount; + Result result; do { result = static_cast( @@ -104117,27 +104228,30 @@ namespace VULKAN_HPP_NAMESPACE properties.resize( propertyCount ); result = static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" ); } - template ::value, int>::type> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getDisplayPlanePropertiesKHR( Allocator const & vectorAllocator, Dispatch const & d ) const + typename ResultValueType>::type + PhysicalDevice::getDisplayPlanePropertiesKHR( + DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator, Dispatch const & d ) const { - std::vector properties( vectorAllocator ); - uint32_t propertyCount; - Result result; + std::vector properties( + displayPlanePropertiesKHRAllocator ); + uint32_t propertyCount; + Result result; do { result = static_cast( @@ -104147,11 +104261,11 @@ namespace VULKAN_HPP_NAMESPACE properties.resize( propertyCount ); result = static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( @@ -104168,14 +104282,16 @@ namespace VULKAN_HPP_NAMESPACE return static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayProperties2KHR( Dispatch const & d ) const + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getDisplayProperties2KHR( Dispatch const & d ) const { - std::vector properties; - uint32_t propertyCount; - Result result; + std::vector properties; + uint32_t propertyCount; + Result result; do { result = @@ -104185,26 +104301,29 @@ namespace VULKAN_HPP_NAMESPACE properties.resize( propertyCount ); result = static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" ); } - template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayProperties2KHR( Allocator const & vectorAllocator, Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator, + Dispatch const & d ) const { - std::vector properties( vectorAllocator ); - uint32_t propertyCount; - Result result; + std::vector properties( displayProperties2KHRAllocator ); + uint32_t propertyCount; + Result result; do { result = @@ -104214,11 +104333,11 @@ namespace VULKAN_HPP_NAMESPACE properties.resize( propertyCount ); result = static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( @@ -104235,14 +104354,16 @@ namespace VULKAN_HPP_NAMESPACE return static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast( pProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayPropertiesKHR( Dispatch const & d ) const + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getDisplayPropertiesKHR( Dispatch const & d ) const { - std::vector properties; - uint32_t propertyCount; - Result result; + std::vector properties; + uint32_t propertyCount; + Result result; do { result = @@ -104252,26 +104373,29 @@ namespace VULKAN_HPP_NAMESPACE properties.resize( propertyCount ); result = static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" ); } - template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayPropertiesKHR( Allocator const & vectorAllocator, Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator, + Dispatch const & d ) const { - std::vector properties( vectorAllocator ); - uint32_t propertyCount; - Result result; + std::vector properties( displayPropertiesKHRAllocator ); + uint32_t propertyCount; + Result result; do { result = @@ -104281,11 +104405,11 @@ namespace VULKAN_HPP_NAMESPACE properties.resize( propertyCount ); result = static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( propertyCount < properties.size() ) ) { - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); properties.resize( propertyCount ); } return createResultValue( @@ -104688,15 +104812,17 @@ namespace VULKAN_HPP_NAMESPACE pFragmentShadingRateCount, reinterpret_cast( pFragmentShadingRates ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< + std::vector>::type PhysicalDevice::getFragmentShadingRatesKHR( Dispatch const & d ) const { - std::vector fragmentShadingRates; - uint32_t fragmentShadingRateCount; - Result result; + std::vector + fragmentShadingRates; + uint32_t fragmentShadingRateCount; + Result result; do { result = static_cast( @@ -104708,28 +104834,32 @@ namespace VULKAN_HPP_NAMESPACE m_physicalDevice, &fragmentShadingRateCount, reinterpret_cast( fragmentShadingRates.data() ) ) ); + VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( fragmentShadingRateCount < fragmentShadingRates.size() ) ) { - VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); fragmentShadingRates.resize( fragmentShadingRateCount ); } return createResultValue( result, fragmentShadingRates, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" ); } - template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getFragmentShadingRatesKHR( Allocator const & vectorAllocator, Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< + std::vector>::type + PhysicalDevice::getFragmentShadingRatesKHR( + PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator, + Dispatch const & d ) const { - std::vector fragmentShadingRates( vectorAllocator ); - uint32_t fragmentShadingRateCount; - Result result; + std::vector + fragmentShadingRates( physicalDeviceFragmentShadingRateKHRAllocator ); + uint32_t fragmentShadingRateCount; + Result result; do { result = static_cast( @@ -104741,11 +104871,11 @@ namespace VULKAN_HPP_NAMESPACE m_physicalDevice, &fragmentShadingRateCount, reinterpret_cast( fragmentShadingRates.data() ) ) ); + VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( fragmentShadingRateCount < fragmentShadingRates.size() ) ) { - VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); fragmentShadingRates.resize( fragmentShadingRateCount ); } return createResultValue( @@ -105012,14 +105142,15 @@ namespace VULKAN_HPP_NAMESPACE return static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast( surface ), pRectCount, reinterpret_cast( pRects ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const { - std::vector rects; - uint32_t rectCount; - Result result; + std::vector rects; + uint32_t rectCount; + Result result; do { result = static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( @@ -105032,27 +105163,28 @@ namespace VULKAN_HPP_NAMESPACE static_cast( surface ), &rectCount, reinterpret_cast( rects.data() ) ) ); + VULKAN_HPP_ASSERT( rectCount <= rects.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( rectCount < rects.size() ) ) { - VULKAN_HPP_ASSERT( rectCount <= rects.size() ); rects.resize( rectCount ); } return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" ); } - template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, - Allocator const & vectorAllocator, + Rect2DAllocator & rect2DAllocator, Dispatch const & d ) const { - std::vector rects( vectorAllocator ); - uint32_t rectCount; - Result result; + std::vector rects( rect2DAllocator ); + uint32_t rectCount; + Result result; do { result = static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( @@ -105065,11 +105197,11 @@ namespace VULKAN_HPP_NAMESPACE static_cast( surface ), &rectCount, reinterpret_cast( rects.data() ) ) ); + VULKAN_HPP_ASSERT( rectCount <= rects.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( rectCount < rects.size() ) ) { - VULKAN_HPP_ASSERT( rectCount <= rects.size() ); rects.resize( rectCount ); } return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" ); @@ -105667,15 +105799,16 @@ namespace VULKAN_HPP_NAMESPACE pCombinationCount, reinterpret_cast( pCombinations ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< + std::vector>::type PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d ) const { - std::vector combinations; - uint32_t combinationCount; - Result result; + std::vector combinations; + uint32_t combinationCount; + Result result; do { result = static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( @@ -105687,11 +105820,11 @@ namespace VULKAN_HPP_NAMESPACE m_physicalDevice, &combinationCount, reinterpret_cast( combinations.data() ) ) ); + VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( combinationCount < combinations.size() ) ) { - VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); combinations.resize( combinationCount ); } return createResultValue( result, @@ -105699,19 +105832,22 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); } - template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( Allocator const & vectorAllocator, - Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< + std::vector>::type + PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( + FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator, + Dispatch const & d ) const { - std::vector combinations( vectorAllocator ); - uint32_t combinationCount; - Result result; + std::vector combinations( + framebufferMixedSamplesCombinationNVAllocator ); + uint32_t combinationCount; + Result result; do { result = static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( @@ -105723,11 +105859,11 @@ namespace VULKAN_HPP_NAMESPACE m_physicalDevice, &combinationCount, reinterpret_cast( combinations.data() ) ) ); + VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( combinationCount < combinations.size() ) ) { - VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); combinations.resize( combinationCount ); } return createResultValue( result, @@ -105851,14 +105987,16 @@ namespace VULKAN_HPP_NAMESPACE pSurfaceFormatCount, reinterpret_cast( pSurfaceFormats ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const { - std::vector surfaceFormats; - uint32_t surfaceFormatCount; - Result result; + std::vector surfaceFormats; + uint32_t surfaceFormatCount; + Result result; do { result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( @@ -105874,28 +106012,30 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast( surfaceFormats.data() ) ) ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) ) { - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); surfaceFormats.resize( surfaceFormatCount ); } return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); } - template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, - Allocator const & vectorAllocator, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, + SurfaceFormat2KHRAllocator & surfaceFormat2KHRAllocator, Dispatch const & d ) const { - std::vector surfaceFormats( vectorAllocator ); - uint32_t surfaceFormatCount; - Result result; + std::vector surfaceFormats( surfaceFormat2KHRAllocator ); + uint32_t surfaceFormatCount; + Result result; do { result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( @@ -105911,11 +106051,11 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast( surfaceFormats.data() ) ) ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) ) { - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); surfaceFormats.resize( surfaceFormatCount ); } return createResultValue( @@ -105936,14 +106076,16 @@ namespace VULKAN_HPP_NAMESPACE pSurfaceFormatCount, reinterpret_cast( pSurfaceFormats ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const { - std::vector surfaceFormats; - uint32_t surfaceFormatCount; - Result result; + std::vector surfaceFormats; + uint32_t surfaceFormatCount; + Result result; do { result = static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( @@ -105956,28 +106098,30 @@ namespace VULKAN_HPP_NAMESPACE static_cast( surface ), &surfaceFormatCount, reinterpret_cast( surfaceFormats.data() ) ) ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) ) { - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); surfaceFormats.resize( surfaceFormatCount ); } return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" ); } - template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, - Allocator const & vectorAllocator, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, + SurfaceFormatKHRAllocator & surfaceFormatKHRAllocator, Dispatch const & d ) const { - std::vector surfaceFormats( vectorAllocator ); - uint32_t surfaceFormatCount; - Result result; + std::vector surfaceFormats( surfaceFormatKHRAllocator ); + uint32_t surfaceFormatCount; + Result result; do { result = static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( @@ -105990,11 +106134,11 @@ namespace VULKAN_HPP_NAMESPACE static_cast( surface ), &surfaceFormatCount, reinterpret_cast( surfaceFormats.data() ) ) ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( surfaceFormatCount < surfaceFormats.size() ) ) { - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); surfaceFormats.resize( surfaceFormatCount ); } return createResultValue( @@ -106016,15 +106160,17 @@ namespace VULKAN_HPP_NAMESPACE pPresentModeCount, reinterpret_cast( pPresentModes ) ) ); } + # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const { - std::vector presentModes; - uint32_t presentModeCount; - Result result; + std::vector presentModes; + uint32_t presentModeCount; + Result result; do { result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( @@ -106040,28 +106186,30 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surfaceInfo ), &presentModeCount, reinterpret_cast( presentModes.data() ) ) ); + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( presentModeCount < presentModes.size() ) ) { - VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); presentModes.resize( presentModeCount ); } return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" ); } - template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, - Allocator const & vectorAllocator, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, + PresentModeKHRAllocator & presentModeKHRAllocator, Dispatch const & d ) const { - std::vector presentModes( vectorAllocator ); - uint32_t presentModeCount; - Result result; + std::vector presentModes( presentModeKHRAllocator ); + uint32_t presentModeCount; + Result result; do { result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( @@ -106077,11 +106225,11 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &surfaceInfo ), &presentModeCount, reinterpret_cast( presentModes.data() ) ) ); + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( presentModeCount < presentModes.size() ) ) { - VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); presentModes.resize( presentModeCount ); } return createResultValue( @@ -106103,14 +106251,16 @@ namespace VULKAN_HPP_NAMESPACE pPresentModeCount, reinterpret_cast( pPresentModes ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d ) const { - std::vector presentModes; - uint32_t presentModeCount; - Result result; + std::vector presentModes; + uint32_t presentModeCount; + Result result; do { result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModesKHR( @@ -106123,28 +106273,30 @@ namespace VULKAN_HPP_NAMESPACE static_cast( surface ), &presentModeCount, reinterpret_cast( presentModes.data() ) ) ); + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( presentModeCount < presentModes.size() ) ) { - VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); presentModes.resize( presentModeCount ); } return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" ); } - template ::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, - Allocator const & vectorAllocator, + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, + PresentModeKHRAllocator & presentModeKHRAllocator, Dispatch const & d ) const { - std::vector presentModes( vectorAllocator ); - uint32_t presentModeCount; - Result result; + std::vector presentModes( presentModeKHRAllocator ); + uint32_t presentModeCount; + Result result; do { result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModesKHR( @@ -106157,11 +106309,11 @@ namespace VULKAN_HPP_NAMESPACE static_cast( surface ), &presentModeCount, reinterpret_cast( presentModes.data() ) ) ); + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( presentModeCount < presentModes.size() ) ) { - VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); presentModes.resize( presentModeCount ); } return createResultValue( @@ -106208,15 +106360,16 @@ namespace VULKAN_HPP_NAMESPACE return static_cast( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, pToolCount, reinterpret_cast( pToolProperties ) ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< + std::vector>::type PhysicalDevice::getToolPropertiesEXT( Dispatch const & d ) const { - std::vector toolProperties; - uint32_t toolCount; - Result result; + std::vector toolProperties; + uint32_t toolCount; + Result result; do { result = static_cast( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) ); @@ -106227,28 +106380,31 @@ namespace VULKAN_HPP_NAMESPACE m_physicalDevice, &toolCount, reinterpret_cast( toolProperties.data() ) ) ); + VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( toolCount < toolProperties.size() ) ) { - VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); toolProperties.resize( toolCount ); } return createResultValue( result, toolProperties, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" ); } + template < - typename Allocator, + typename PhysicalDeviceToolPropertiesEXTAllocator, typename Dispatch, typename B, typename std::enable_if::value, int>::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getToolPropertiesEXT( Allocator const & vectorAllocator, Dispatch const & d ) const + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType< + std::vector>::type + PhysicalDevice::getToolPropertiesEXT( + PhysicalDeviceToolPropertiesEXTAllocator & physicalDeviceToolPropertiesEXTAllocator, Dispatch const & d ) const { - std::vector toolProperties( vectorAllocator ); - uint32_t toolCount; - Result result; + std::vector toolProperties( + physicalDeviceToolPropertiesEXTAllocator ); + uint32_t toolCount; + Result result; do { result = static_cast( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) ); @@ -106259,11 +106415,11 @@ namespace VULKAN_HPP_NAMESPACE m_physicalDevice, &toolCount, reinterpret_cast( toolProperties.data() ) ) ); + VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); } } while ( result == Result::eIncomplete ); - if ( result == Result::eSuccess ) + if ( ( result == Result::eSuccess ) && ( toolCount < toolProperties.size() ) ) { - VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); toolProperties.resize( toolCount ); } return createResultValue(