mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-10-14 16:32:17 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Add support of functions taking and returning a vector of data

Browse Source
This commit is contained in:
asuessenbach 2021-10-06 09:47:13 +02:00
parent 511437e473
commit 6db58639f8
4 changed files with 426 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

314
VulkanHppGenerator.cpp
View File

@ -3948,14 +3948,14 @@ std::string
} }
} }
std::string std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesOrValues(
VulkanHppGenerator::generateCommandResultGetVectorOfHandles( std::string const & name, std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
bool definition, bool definition,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
size_t returnParamIndex, size_t returnParamIndex,
bool withAllocator ) const bool withAllocator ) const
{ {
assert( commandData.returnType == "VkResult" ); assert( commandData.returnType == "VkResult" );
@ -3966,27 +3966,29 @@ std::string
generateArgumentListEnhanced( commandData.params, skippedParams, {}, definition, withAllocator, false, true ); generateArgumentListEnhanced( commandData.params, skippedParams, {}, definition, withAllocator, false, true );
std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags ); std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
std::string handleType = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" ); assert( beginsWith( commandData.params[returnParamIndex].type.type, "Vk" ) );
std::string elementType = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
std::string returnType = std::string returnType =
( commandData.successCodes.size() == 1 ) ( commandData.successCodes.size() == 1 )
? ( "typename ResultValueType<std::vector<" + handleType + ", " + handleType + "Allocator>>::type" ) ? ( "typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::" + elementType + ", " + elementType +
: ( "ResultValue<std::vector<" + handleType + ", " + handleType + "Allocator>>" ); "Allocator>>::type" )
: ( "ResultValue<std::vector<VULKAN_HPP_NAMESPACE::" + elementType + ", " + elementType + "Allocator>>" );
if ( definition ) if ( definition )
{ {
std::string const functionTemplate = std::string const functionTemplate =
R"( template <typename ${handleType}Allocator, typename Dispatch${typenameCheck}> R"( template <typename ${elementType}Allocator, typename Dispatch${typenameCheck}>
${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}${classSeparator}${commandName}( ${argumentList} ) const ${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}${classSeparator}${commandName}( ${argumentList} ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<${handleType}, ${handleType}Allocator> ${vectorName}( ${vectorSize}${vectorAllocator} ); std::vector<VULKAN_HPP_NAMESPACE::${elementType}, ${elementType}Allocator> ${vectorName}( ${vectorSize}${vectorAllocator} );
Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) ); Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) );
return createResultValue( result, ${vectorName}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} ); return createResultValue( result, ${vectorName}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} );
})"; })";
std::string typenameCheck = withAllocator std::string typenameCheck = withAllocator
? ( ", typename B, typename std::enable_if<std::is_same<typename B::value_type, " + ? ( ", typename B, typename std::enable_if<std::is_same<typename B::value_type, " +
handleType + ">::value, int>::type " ) elementType + ">::value, int>::type " )
: ""; : "";
std::string vectorName = startLowerCase( stripPrefix( commandData.params[returnParamIndex].name, "p" ) ); std::string vectorName = startLowerCase( stripPrefix( commandData.params[returnParamIndex].name, "p" ) );
@ -3998,12 +4000,12 @@ std::string
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
{ "commandName", commandName }, { "commandName", commandName },
{ "elementType", elementType },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
{ "handleType", handleType },
{ "returnType", returnType }, { "returnType", returnType },
{ "typenameCheck", typenameCheck }, { "typenameCheck", typenameCheck },
{ "successCodeList", generateSuccessCodeList( commandData.successCodes ) }, { "successCodeList", generateSuccessCodeList( commandData.successCodes ) },
{ "vectorAllocator", withAllocator ? ( ", " + startLowerCase( handleType ) + "Allocator" ) : "" }, { "vectorAllocator", withAllocator ? ( ", " + startLowerCase( elementType ) + "Allocator" ) : "" },
{ "vectorName", vectorName }, { "vectorName", vectorName },
{ "vectorSize", getVectorSize( commandData.params, vectorParamIndices, returnParamIndex ) }, { "vectorSize", getVectorSize( commandData.params, vectorParamIndices, returnParamIndex ) },
{ "vkCommand", name } } ); { "vkCommand", name } } );
@ -4011,26 +4013,26 @@ std::string
else else
{ {
std::string const functionTemplate = std::string const functionTemplate =
R"( template <typename ${handleType}Allocator = std::allocator<${handleType}>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${typenameCheck}> R"( template <typename ${elementType}Allocator = std::allocator<${elementType}>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${typenameCheck}>
${nodiscard}${returnType} ${commandName}( ${argumentList} ) const;)"; ${nodiscard}${returnType} ${commandName}( ${argumentList} ) const;)";
std::string typenameCheck = withAllocator std::string typenameCheck = withAllocator
? ( ", typename B = " + handleType + ? ( ", typename B = " + elementType +
"Allocator, typename std::enable_if<std::is_same<typename B::value_type, " + "Allocator, typename std::enable_if<std::is_same<typename B::value_type, " +
handleType + ">::value, int>::type = 0" ) elementType + ">::value, int>::type = 0" )
: ""; : "";
return replaceWithMap( functionTemplate, return replaceWithMap( functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "commandName", commandName }, { "commandName", commandName },
{ "handleType", handleType }, { "elementType", elementType },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
{ "returnType", returnType }, { "returnType", returnType },
{ "typenameCheck", typenameCheck } } ); { "typenameCheck", typenameCheck } } );
} }
} }
std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesSingular( std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesOrValuesSingular(
std::string const & name, std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
@ -4050,10 +4052,11 @@ std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesSingular(
generateArgumentListEnhanced( commandData.params, skippedParams, singularParams, definition, false, false, true ); generateArgumentListEnhanced( commandData.params, skippedParams, singularParams, definition, false, false, true );
std::string commandName = stripPluralS( generateCommandName( name, commandData.params, initialSkipCount, m_tags ) ); std::string commandName = stripPluralS( generateCommandName( name, commandData.params, initialSkipCount, m_tags ) );
std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
std::string handleType = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" ); assert( beginsWith( commandData.params[returnParamIndex].type.type, "Vk" ) );
std::string returnType = ( commandData.successCodes.size() == 1 ) std::string dataType = "VULKAN_HPP_NAMESPACE::" + stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
? ( "typename ResultValueType<" + handleType + ">::type" ) std::string returnType = ( commandData.successCodes.size() == 1 )
: ( "ResultValue<" + handleType + ">" ); ? ( "typename ResultValueType<" + dataType + ">::type" )
: ( "ResultValue<" + dataType + ">" );
if ( definition ) if ( definition )
{ {
@ -4062,9 +4065,9 @@ std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesSingular(
${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}${classSeparator}${commandName}( ${argumentList} ) const ${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}${classSeparator}${commandName}( ${argumentList} ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
${handleType} ${handleName}; ${dataType} ${dataName};
Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) ); Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) );
return createResultValue( result, ${handleName}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} ); return createResultValue( result, ${dataName}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} );
})"; })";
return replaceWithMap( return replaceWithMap(
@ -4076,10 +4079,9 @@ std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesSingular(
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
{ "commandName", commandName }, { "commandName", commandName },
{ "dataName", stripPluralS( startLowerCase( stripPrefix( commandData.params[returnParamIndex].name, "p" ) ) ) },
{ "dataType", dataType },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
{ "handleName",
stripPluralS( startLowerCase( stripPrefix( commandData.params[returnParamIndex].name, "p" ) ) ) },
{ "handleType", handleType },
{ "returnType", returnType }, { "returnType", returnType },
{ "successCodeList", generateSuccessCodeList( commandData.successCodes ) }, { "successCodeList", generateSuccessCodeList( commandData.successCodes ) },
{ "vkCommand", name } } ); { "vkCommand", name } } );
@ -4514,11 +4516,11 @@ std::string VulkanHppGenerator::generateCommandResultMultiSuccessWithErrors1Retu
return generateCommandSetStandardEnhancedWithAllocatorSingularUnique( return generateCommandSetStandardEnhancedWithAllocatorSingularUnique(
definition, definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetVectorOfHandles( generateCommandResultGetVectorOfHandlesOrValues(
name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, false ), name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, false ),
generateCommandResultGetVectorOfHandles( generateCommandResultGetVectorOfHandlesOrValues(
name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, true ), name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, true ),
generateCommandResultGetVectorOfHandlesSingular( generateCommandResultGetVectorOfHandlesOrValuesSingular(
name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex ), name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex ),
generateCommandResultGetVectorOfHandlesUnique( generateCommandResultGetVectorOfHandlesUnique(
name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, false ), name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, false ),
@ -4839,9 +4841,9 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret
return generateCommandSetStandardEnhancedWithAllocatorUnique( return generateCommandSetStandardEnhancedWithAllocatorUnique(
definition, definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetVectorOfHandles( generateCommandResultGetVectorOfHandlesOrValues(
name, commandData, initialSkipCount, definition, { vectorParamIndex }, returnParamIndex, false ), name, commandData, initialSkipCount, definition, { vectorParamIndex }, returnParamIndex, false ),
generateCommandResultGetVectorOfHandles( generateCommandResultGetVectorOfHandlesOrValues(
name, commandData, initialSkipCount, definition, { vectorParamIndex }, returnParamIndex, true ), name, commandData, initialSkipCount, definition, { vectorParamIndex }, returnParamIndex, true ),
generateCommandResultGetVectorOfHandlesUnique( generateCommandResultGetVectorOfHandlesUnique(
name, commandData, initialSkipCount, definition, { vectorParamIndex }, returnParamIndex, false ), name, commandData, initialSkipCount, definition, { vectorParamIndex }, returnParamIndex, false ),
@ -4871,11 +4873,11 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1Ret
return generateCommandSetStandardEnhancedWithAllocatorSingularUnique( return generateCommandSetStandardEnhancedWithAllocatorSingularUnique(
definition, definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetVectorOfHandles( generateCommandResultGetVectorOfHandlesOrValues(
name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, false ), name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, false ),
generateCommandResultGetVectorOfHandles( generateCommandResultGetVectorOfHandlesOrValues(
name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, true ), name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, true ),
generateCommandResultGetVectorOfHandlesSingular( generateCommandResultGetVectorOfHandlesOrValuesSingular(
name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex ), name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex ),
generateCommandResultGetVectorOfHandlesUnique( generateCommandResultGetVectorOfHandlesUnique(
name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, false ), name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, false ),
@ -4898,12 +4900,51 @@ std::string
size_t returnParamIndex ) const size_t returnParamIndex ) const
{ {
std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices( commandData.params ); std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices( commandData.params );
if ( vectorParamIndices.empty() ) switch ( vectorParamIndices.size() )
{ {
return generateCommandSetStandardEnhanced( case 0:
definition, return generateCommandSetStandardEnhanced(
generateCommandStandard( name, commandData, initialSkipCount, definition ), definition,
generateCommandResultGetValue( name, commandData, initialSkipCount, definition, returnParamIndex ) ); generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetValue( name, commandData, initialSkipCount, definition, returnParamIndex ) );
case 2:
return generateCommandResultSingleSuccessWithErrors1ReturnValue2Vectors(
name, commandData, initialSkipCount, definition, returnParamIndex, vectorParamIndices );
break;
}
return "";
}
std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors1ReturnValue2Vectors(
std::string const & name,
CommandData const & commandData,
size_t initialSkipCount,
bool definition,
size_t returnParamIndex,
std::map<size_t, size_t> const & vectorParamIndices ) const
{
if ( returnParamIndex == std::next( vectorParamIndices.begin() )->first )
{
if ( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second )
{
if ( commandData.params[vectorParamIndices.begin()->second].type.type == "uint32_t" )
{
if ( ( commandData.params[vectorParamIndices.begin()->first].type.type != "void" ) &&
!isHandleType( commandData.params[vectorParamIndices.begin()->first].type.type ) &&
!isStructureChainAnchor( commandData.params[vectorParamIndices.begin()->first].type.type ) )
{
return generateCommandSetStandardEnhancedWithAllocatorSingular(
definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetVectorOfHandlesOrValues(
name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, false ),
generateCommandResultGetVectorOfHandlesOrValues(
name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex, true ),
generateCommandResultGetVectorOfHandlesOrValuesSingular(
name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndex ) );
}
}
}
} }
return ""; return "";
} }
@ -5223,6 +5264,31 @@ ${commandEnhancedWithAllocator}
{ "newlineOnDefinition", definition ? "\n" : "" } } ) ); { "newlineOnDefinition", definition ? "\n" : "" } } ) );
} }
std::string VulkanHppGenerator::generateCommandSetStandardEnhancedWithAllocatorSingular(
bool definition,
std::string const & standard,
std::string const & enhanced,
std::string const & enhancedWithAllocator,
std::string const & enhancedSingular ) const
{
std::string const commandTemplate = R"(
${commandStandard}${newlineOnDefinition}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
${commandEnhanced}${newlineOnDefinition}
${commandEnhancedWithAllocator}${newlineOnDefinition}
${commandEnhancedSingular}${newlineOnDefinition}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
)";
return replaceWithMap(
commandTemplate,
std::map<std::string, std::string>( { { "commandEnhanced", enhanced },
{ "commandEnhancedSingular", enhancedSingular },
{ "commandEnhancedWithAllocator", enhancedWithAllocator },
{ "commandStandard", standard },
{ "newlineOnDefinition", definition ? "\n" : "" } } ) );
}
std::string VulkanHppGenerator::generateCommandSetStandardEnhancedWithAllocatorSingularUnique( std::string VulkanHppGenerator::generateCommandSetStandardEnhancedWithAllocatorSingularUnique(
bool definition, bool definition,
std::string const & standard, std::string const & standard,
@ -8333,10 +8399,32 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
else if ( commandIt->second.params[returnParamIndex].type.type != "void" ) else if ( commandIt->second.params[returnParamIndex].type.type != "void" )
{ {
std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices( commandIt->second.params ); std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices( commandIt->second.params );
if ( vectorParamIndices.empty() ) switch ( vectorParamIndices.size() )
{ {
str = generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValue( case 0:
commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition ); str = generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValue(
commandIt, initialSkipCount, vectorParamIndices, { returnParamIndex }, definition );
break;
case 2:
if ( returnParamIndex == std::next( vectorParamIndices.begin() )->first )
{
if ( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second )
{
if ( commandIt->second.params[vectorParamIndices.begin()->second].type.type == "uint32_t" )
{
if ( ( commandIt->second.params[vectorParamIndices.begin()->first].type.type != "void" ) &&
!isHandleType( commandIt->second.params[vectorParamIndices.begin()->first].type.type ) &&
!isStructureChainAnchor( commandIt->second.params[vectorParamIndices.begin()->first].type.type ) )
{
str = generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueVector(
commandIt, initialSkipCount, returnParamIndex, vectorParamIndices, definition );
str += generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueSingular(
commandIt, initialSkipCount, returnParamIndex, vectorParamIndices, definition );
}
}
}
}
break;
} }
} }
else else
@ -8456,6 +8544,136 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
} }
} }
std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueSingular(
std::map<std::string, CommandData>::const_iterator commandIt,
size_t initialSkipCount,
size_t returnParamIndex,
std::map<size_t, size_t> const & vectorParamIndices,
bool definition ) const
{
assert( vectorParamIndices.size() == 2 );
assert( returnParamIndex == std::next( vectorParamIndices.begin() )->first );
assert( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second );
std::set<size_t> skippedParameters = determineSkippedParams(
commandIt->second.params, initialSkipCount, vectorParamIndices, { returnParamIndex }, true );
std::set<size_t> singularParams = determineSingularParams( returnParamIndex, vectorParamIndices );
std::string argumentList = generateArgumentListEnhanced(
commandIt->second.params, skippedParameters, singularParams, definition, false, false, false );
std::string commandName =
stripPluralS( generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ) );
assert( beginsWith( commandIt->second.params[returnParamIndex].type.type, "Vk" ) );
std::string dataType =
"VULKAN_HPP_NAMESPACE::" + stripPrefix( commandIt->second.params[returnParamIndex].type.type, "Vk" );
if ( definition )
{
std::string const singularDefinitionTemplate =
R"(
VULKAN_HPP_NODISCARD ${dataType} ${className}::${commandName}( ${argumentList} ) const
{
${dataType} ${dataName};
Result result = static_cast<Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
if ( ${failureCheck} )
{
throwResultException( result, VULKAN_HPP_NAMESPACE_STRING"::${className}::${commandName}" );
}
return ${dataName};
}
)";
return replaceWithMap(
singularDefinitionTemplate,
{ { "argumentList", argumentList },
{ "callArguments", generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, singularParams, true ) },
{ "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
{ "commandName", commandName },
{ "dataName", stripPluralS( startLowerCase( stripPrefix( commandIt->second.params[returnParamIndex].name, "p" ) ) ) },
{ "dataType", dataType },
{ "failureCheck", generateFailureCheck( commandIt->second.successCodes ) },
{ "vkCommand", commandIt->first } } );
}
else
{
std::string const singularDeclarationTemplate =
R"(
VULKAN_HPP_NODISCARD ${dataType} ${commandName}( ${argumentList} ) const;
)";
return replaceWithMap( singularDeclarationTemplate,
{
{ "argumentList", argumentList },
{ "commandName", commandName },
{ "dataType", dataType }
} );
}
}
std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueVector(
std::map<std::string, CommandData>::const_iterator commandIt,
size_t initialSkipCount,
size_t returnParamIndex,
std::map<size_t, size_t> const & vectorParamIndices,
bool definition ) const
{
assert( vectorParamIndices.size() == 2 );
assert( returnParamIndex == std::next( vectorParamIndices.begin() )->first );
assert( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second );
std::set<size_t> skippedParameters = determineSkippedParams(
commandIt->second.params, initialSkipCount, vectorParamIndices, { returnParamIndex }, false );
std::string argumentList =
generateArgumentListEnhanced( commandIt->second.params, skippedParameters, {}, definition, false, false, false );
std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
assert( beginsWith( commandIt->second.params[returnParamIndex].type.type, "Vk" ) );
std::string elementType =
"VULKAN_HPP_NAMESPACE::" + stripPrefix( commandIt->second.params[returnParamIndex].type.type, "Vk" );
if ( definition )
{
std::string const definitionTemplate =
R"(
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${elementType}> ${className}::${commandName}( ${argumentList} ) const
{${functionPointerCheck}
std::vector<${elementType}> ${vectorName}( ${vectorSize} );
Result result = static_cast<Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
if ( ${failureCheck} )
{
throwResultException( result, VULKAN_HPP_NAMESPACE_STRING"::${className}::${commandName}" );
}
return ${vectorName};
}
)";
return replaceWithMap(
definitionTemplate,
{ { "argumentList", argumentList },
{ "callArguments",
generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true ) },
{ "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
{ "commandName", commandName },
{ "elementType", elementType },
{ "failureCheck", generateFailureCheck( commandIt->second.successCodes ) },
{ "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
{ "vectorName", startLowerCase( stripPrefix( commandIt->second.params[returnParamIndex].name, "p" ) ) },
{ "vectorSize",
startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) ) +
".size()" },
{ "vkCommand", commandIt->first } } );
}
else
{
std::string const declarationTemplate =
R"(
VULKAN_HPP_NODISCARD std::vector<${elementType}> ${commandName}( ${argumentList} ) const;
)";
return replaceWithMap(
declarationTemplate,
{ { "argumentList", argumentList }, { "commandName", commandName }, { "elementType", elementType } } );
}
}
std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnVoidSingular( std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnVoidSingular(
std::map<std::string, CommandData>::const_iterator commandIt, std::map<std::string, CommandData>::const_iterator commandIt,
size_t initialSkipCount, size_t initialSkipCount,
@ -17045,8 +17263,8 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
tinyxml2::XMLError error = doc.LoadFile( filename.c_str() ); tinyxml2::XMLError error = doc.LoadFile( filename.c_str() );
if ( error != tinyxml2::XML_SUCCESS ) if ( error != tinyxml2::XML_SUCCESS )
{ {
std::cout << "VulkanHppGenerator: failed to load file " << filename << " with error <" << toString( error ) std::cout << "VulkanHppGenerator: failed to load file " << filename << " with error <" << toString( error ) << ">"
<< ">" << std::endl; << std::endl;
return -1; return -1;
} }

55
VulkanHppGenerator.hpp
View File

@ -532,19 +532,20 @@ private:
bool definition, bool definition,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
size_t returnParamIndex ) const; size_t returnParamIndex ) const;
std::string generateCommandResultGetVectorOfHandles( std::string const & name, std::string generateCommandResultGetVectorOfHandlesOrValues( std::string const & name,
CommandData const & commandData,
size_t initialSkipCount,
bool definition,
std::map<size_t, size_t> const & vectorParamIndices,
size_t returnParamIndex,
bool withAllocator ) const;
std::string generateCommandResultGetVectorOfHandlesSingular( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
bool definition, bool definition,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
size_t returnParamIndex ) const; size_t returnParamIndex,
bool withAllocator ) const;
std::string
generateCommandResultGetVectorOfHandlesOrValuesSingular( std::string const & name,
CommandData const & commandData,
size_t initialSkipCount,
bool definition,
std::map<size_t, size_t> const & vectorParamIndices,
size_t returnParamIndex ) const;
std::string generateCommandResultGetVectorOfHandlesUnique( std::string const & name, std::string generateCommandResultGetVectorOfHandlesUnique( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
@ -645,6 +646,13 @@ private:
size_t initialSkipCount, size_t initialSkipCount,
bool definition, bool definition,
size_t returnParamIndex ) const; size_t returnParamIndex ) const;
std::string generateCommandResultSingleSuccessWithErrors1ReturnValue2Vectors(
std::string const & name,
CommandData const & commandData,
size_t initialSkipCount,
bool definition,
size_t returnParamIndex,
std::map<size_t, size_t> const & vectorParamIndices ) const;
std::string generateCommandResultSingleSuccessWithErrors1ReturnVoid( std::string const & name, std::string generateCommandResultSingleSuccessWithErrors1ReturnVoid( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
@ -692,12 +700,17 @@ private:
std::string const & enhancedWithAllocator, std::string const & enhancedWithAllocator,
std::string const & enhancedSingular ) const; std::string const & enhancedSingular ) const;
std::string std::string
generateCommandSetStandardEnhancedWithAllocatorDeprecated2( bool definition, generateCommandSetStandardEnhancedWithAllocatorDeprecated2( bool definition,
std::string const & standard, std::string const & standard,
std::string const & enhancedDeprecated, std::string const & enhancedDeprecated,
std::string const & enhancedWithAllocatorDeprecated, std::string const & enhancedWithAllocatorDeprecated,
std::string const & enhanced, std::string const & enhanced,
std::string const & enhancedWithAllocator ) const; std::string const & enhancedWithAllocator ) const;
std::string generateCommandSetStandardEnhancedWithAllocatorSingular( bool definition,
std::string const & standard,
std::string const & enhanced,
std::string const & enhancedWithAllocator,
std::string const & enhancedSingular ) const;
std::string std::string
generateCommandSetStandardEnhancedWithAllocatorSingularUnique( bool definition, generateCommandSetStandardEnhancedWithAllocatorSingularUnique( bool definition,
std::string const & standard, std::string const & standard,
@ -973,6 +986,18 @@ private:
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
std::vector<size_t> const & nonConstPointerParamIndices, std::vector<size_t> const & nonConstPointerParamIndices,
bool definition ) const; bool definition ) const;
std::string generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueSingular(
std::map<std::string, CommandData>::const_iterator commandIt,
size_t initialSkipCount,
size_t returnParamIndex,
std::map<size_t, size_t> const & vectorParamIndices,
bool definition ) const;
std::string generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueVector(
std::map<std::string, CommandData>::const_iterator commandIt,
size_t initialSkipCount,
size_t returnParamIndex,
std::map<size_t, size_t> const & vectorParamIndices,
bool definition ) const;
std::string generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnVoidSingular( std::string generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnVoidSingular(
std::map<std::string, CommandData>::const_iterator commandIt, std::map<std::string, CommandData>::const_iterator commandIt,
size_t initialSkipCount, size_t initialSkipCount,

122
vulkan/vulkan_funcs.hpp
View File

@ -2818,7 +2818,7 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineAllocator, typename Dispatch> template <typename PipelineAllocator, typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
Device::createGraphicsPipelines( Device::createGraphicsPipelines(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
@ -2826,8 +2826,8 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() ); std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkCreateGraphicsPipelines( m_device, d.vkCreateGraphicsPipelines( m_device,
static_cast<VkPipelineCache>( pipelineCache ), static_cast<VkPipelineCache>( pipelineCache ),
createInfos.size(), createInfos.size(),
@ -2846,7 +2846,7 @@ namespace VULKAN_HPP_NAMESPACE
typename Dispatch, typename Dispatch,
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
Device::createGraphicsPipelines( Device::createGraphicsPipelines(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
@ -2855,8 +2855,8 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator ); std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkCreateGraphicsPipelines( m_device, d.vkCreateGraphicsPipelines( m_device,
static_cast<VkPipelineCache>( pipelineCache ), static_cast<VkPipelineCache>( pipelineCache ),
createInfos.size(), createInfos.size(),
@ -2872,15 +2872,15 @@ namespace VULKAN_HPP_NAMESPACE
} }
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
Device::createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Device::createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator, Optional<const AllocationCallbacks> allocator,
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
Pipeline pipeline; VULKAN_HPP_NAMESPACE::Pipeline pipeline;
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkCreateGraphicsPipelines( m_device, d.vkCreateGraphicsPipelines( m_device,
static_cast<VkPipelineCache>( pipelineCache ), static_cast<VkPipelineCache>( pipelineCache ),
1, 1,
@ -3022,7 +3022,7 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineAllocator, typename Dispatch> template <typename PipelineAllocator, typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
Device::createComputePipelines( Device::createComputePipelines(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
@ -3030,8 +3030,8 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() ); std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkCreateComputePipelines( m_device, d.vkCreateComputePipelines( m_device,
static_cast<VkPipelineCache>( pipelineCache ), static_cast<VkPipelineCache>( pipelineCache ),
createInfos.size(), createInfos.size(),
@ -3050,7 +3050,7 @@ namespace VULKAN_HPP_NAMESPACE
typename Dispatch, typename Dispatch,
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
Device::createComputePipelines( Device::createComputePipelines(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
@ -3059,8 +3059,8 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator ); std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkCreateComputePipelines( m_device, d.vkCreateComputePipelines( m_device,
static_cast<VkPipelineCache>( pipelineCache ), static_cast<VkPipelineCache>( pipelineCache ),
createInfos.size(), createInfos.size(),
@ -3076,15 +3076,15 @@ namespace VULKAN_HPP_NAMESPACE
} }
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
Device::createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Device::createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator, Optional<const AllocationCallbacks> allocator,
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
Pipeline pipeline; VULKAN_HPP_NAMESPACE::Pipeline pipeline;
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkCreateComputePipelines( m_device, d.vkCreateComputePipelines( m_device,
static_cast<VkPipelineCache>( pipelineCache ), static_cast<VkPipelineCache>( pipelineCache ),
1, 1,
@ -3720,12 +3720,13 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DescriptorSetAllocator, typename Dispatch> template <typename DescriptorSetAllocator, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount ); std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator> descriptorSets(
Result result = static_cast<Result>( allocateInfo.descriptorSetCount );
Result result = static_cast<Result>(
d.vkAllocateDescriptorSets( m_device, d.vkAllocateDescriptorSets( m_device,
reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ),
reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) ); reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
@ -3737,15 +3738,15 @@ namespace VULKAN_HPP_NAMESPACE
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, DescriptorSet>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, DescriptorSet>::value, int>::type>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
DescriptorSetAllocator & descriptorSetAllocator, DescriptorSetAllocator & descriptorSetAllocator,
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<DescriptorSet, DescriptorSetAllocator> descriptorSets( allocateInfo.descriptorSetCount, std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator> descriptorSets(
descriptorSetAllocator ); allocateInfo.descriptorSetCount, descriptorSetAllocator );
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkAllocateDescriptorSets( m_device, d.vkAllocateDescriptorSets( m_device,
reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ),
reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) ); reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
@ -4289,12 +4290,13 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename CommandBufferAllocator, typename Dispatch> template <typename CommandBufferAllocator, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount ); std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator> commandBuffers(
Result result = static_cast<Result>( allocateInfo.commandBufferCount );
Result result = static_cast<Result>(
d.vkAllocateCommandBuffers( m_device, d.vkAllocateCommandBuffers( m_device,
reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ),
reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) ); reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
@ -4306,15 +4308,15 @@ namespace VULKAN_HPP_NAMESPACE
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, CommandBuffer>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, CommandBuffer>::value, int>::type>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
CommandBufferAllocator & commandBufferAllocator, CommandBufferAllocator & commandBufferAllocator,
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<CommandBuffer, CommandBufferAllocator> commandBuffers( allocateInfo.commandBufferCount, std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator> commandBuffers(
commandBufferAllocator ); allocateInfo.commandBufferCount, commandBufferAllocator );
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkAllocateCommandBuffers( m_device, d.vkAllocateCommandBuffers( m_device,
reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ),
reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) ); reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
@ -8072,15 +8074,15 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename SwapchainKHRAllocator, typename Dispatch> template <typename SwapchainKHRAllocator, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
Device::createSharedSwapchainsKHR( Device::createSharedSwapchainsKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
Optional<const AllocationCallbacks> allocator, Optional<const AllocationCallbacks> allocator,
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size() ); std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size() );
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkCreateSharedSwapchainsKHR( m_device, d.vkCreateSharedSwapchainsKHR( m_device,
createInfos.size(), createInfos.size(),
reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ), reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
@ -8095,7 +8097,7 @@ namespace VULKAN_HPP_NAMESPACE
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, SwapchainKHR>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, SwapchainKHR>::value, int>::type>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
Device::createSharedSwapchainsKHR( Device::createSharedSwapchainsKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
Optional<const AllocationCallbacks> allocator, Optional<const AllocationCallbacks> allocator,
@ -8103,8 +8105,9 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size(), swapchainKHRAllocator ); std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator> swapchains( createInfos.size(),
Result result = static_cast<Result>( swapchainKHRAllocator );
Result result = static_cast<Result>(
d.vkCreateSharedSwapchainsKHR( m_device, d.vkCreateSharedSwapchainsKHR( m_device,
createInfos.size(), createInfos.size(),
reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ), reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
@ -8115,14 +8118,15 @@ namespace VULKAN_HPP_NAMESPACE
} }
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<SwapchainKHR>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
Device::createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, Device::createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator, Optional<const AllocationCallbacks> allocator,
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
SwapchainKHR swapchain; VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain;
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkCreateSharedSwapchainsKHR( m_device, d.vkCreateSharedSwapchainsKHR( m_device,
1, 1,
reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ), reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
@ -14868,7 +14872,7 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineAllocator, typename Dispatch> template <typename PipelineAllocator, typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
Device::createRayTracingPipelinesNV( Device::createRayTracingPipelinesNV(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
@ -14876,8 +14880,8 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() ); std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkCreateRayTracingPipelinesNV( m_device, d.vkCreateRayTracingPipelinesNV( m_device,
static_cast<VkPipelineCache>( pipelineCache ), static_cast<VkPipelineCache>( pipelineCache ),
createInfos.size(), createInfos.size(),
@ -14896,7 +14900,7 @@ namespace VULKAN_HPP_NAMESPACE
typename Dispatch, typename Dispatch,
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
Device::createRayTracingPipelinesNV( Device::createRayTracingPipelinesNV(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
@ -14905,8 +14909,8 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator ); std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkCreateRayTracingPipelinesNV( m_device, d.vkCreateRayTracingPipelinesNV( m_device,
static_cast<VkPipelineCache>( pipelineCache ), static_cast<VkPipelineCache>( pipelineCache ),
createInfos.size(), createInfos.size(),
@ -14922,15 +14926,15 @@ namespace VULKAN_HPP_NAMESPACE
} }
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
Device::createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Device::createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
Optional<const AllocationCallbacks> allocator, Optional<const AllocationCallbacks> allocator,
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
Pipeline pipeline; VULKAN_HPP_NAMESPACE::Pipeline pipeline;
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkCreateRayTracingPipelinesNV( m_device, d.vkCreateRayTracingPipelinesNV( m_device,
static_cast<VkPipelineCache>( pipelineCache ), static_cast<VkPipelineCache>( pipelineCache ),
1, 1,
@ -18555,7 +18559,7 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineAllocator, typename Dispatch> template <typename PipelineAllocator, typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
Device::createRayTracingPipelinesKHR( Device::createRayTracingPipelinesKHR(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
@ -18564,8 +18568,8 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size() ); std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size() );
Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR( Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR(
m_device, m_device,
static_cast<VkDeferredOperationKHR>( deferredOperation ), static_cast<VkDeferredOperationKHR>( deferredOperation ),
static_cast<VkPipelineCache>( pipelineCache ), static_cast<VkPipelineCache>( pipelineCache ),
@ -18587,7 +18591,7 @@ namespace VULKAN_HPP_NAMESPACE
typename Dispatch, typename Dispatch,
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<Pipeline, PipelineAllocator>> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
Device::createRayTracingPipelinesKHR( Device::createRayTracingPipelinesKHR(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
@ -18597,8 +18601,8 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::vector<Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator ); std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator> pipelines( createInfos.size(), pipelineAllocator );
Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR( Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesKHR(
m_device, m_device,
static_cast<VkDeferredOperationKHR>( deferredOperation ), static_cast<VkDeferredOperationKHR>( deferredOperation ),
static_cast<VkPipelineCache>( pipelineCache ), static_cast<VkPipelineCache>( pipelineCache ),
@ -18617,7 +18621,7 @@ namespace VULKAN_HPP_NAMESPACE
} }
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<Pipeline> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<VULKAN_HPP_NAMESPACE::Pipeline>
Device::createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, Device::createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo,
@ -18625,8 +18629,8 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
Pipeline pipeline; VULKAN_HPP_NAMESPACE::Pipeline pipeline;
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkCreateRayTracingPipelinesKHR( m_device, d.vkCreateRayTracingPipelinesKHR( m_device,
static_cast<VkDeferredOperationKHR>( deferredOperation ), static_cast<VkDeferredOperationKHR>( deferredOperation ),
static_cast<VkPipelineCache>( pipelineCache ), static_cast<VkPipelineCache>( pipelineCache ),

107
vulkan/vulkan_handles.hpp
View File

@ -8220,23 +8220,24 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineAllocator = std::allocator<Pipeline>, template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createGraphicsPipelines( VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Optional<const AllocationCallbacks> allocator
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PipelineAllocator = std::allocator<Pipeline>, template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PipelineAllocator, typename B = PipelineAllocator,
typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0> typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
Optional<const AllocationCallbacks> allocator, Optional<const AllocationCallbacks> allocator,
PipelineAllocator & pipelineAllocator, PipelineAllocator & pipelineAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<Pipeline> createGraphicsPipeline( VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createGraphicsPipeline(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo, const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@ -8282,23 +8283,24 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineAllocator = std::allocator<Pipeline>, template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createComputePipelines( VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Optional<const AllocationCallbacks> allocator
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PipelineAllocator = std::allocator<Pipeline>, template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PipelineAllocator, typename B = PipelineAllocator,
typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0> typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
Optional<const AllocationCallbacks> allocator, Optional<const AllocationCallbacks> allocator,
PipelineAllocator & pipelineAllocator, PipelineAllocator & pipelineAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<Pipeline> createComputePipeline( VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createComputePipeline(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo, const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@ -8563,7 +8565,7 @@ namespace VULKAN_HPP_NAMESPACE
template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>, template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>, template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
@ -8571,7 +8573,7 @@ namespace VULKAN_HPP_NAMESPACE
typename B = DescriptorSetAllocator, typename B = DescriptorSetAllocator,
typename std::enable_if<std::is_same<typename B::value_type, DescriptorSet>::value, int>::type = 0> typename std::enable_if<std::is_same<typename B::value_type, DescriptorSet>::value, int>::type = 0>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet, DescriptorSetAllocator>>::type
allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
DescriptorSetAllocator & descriptorSetAllocator, DescriptorSetAllocator & descriptorSetAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@ -8808,7 +8810,7 @@ namespace VULKAN_HPP_NAMESPACE
template <typename CommandBufferAllocator = std::allocator<CommandBuffer>, template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename CommandBufferAllocator = std::allocator<CommandBuffer>, template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
@ -8816,7 +8818,7 @@ namespace VULKAN_HPP_NAMESPACE
typename B = CommandBufferAllocator, typename B = CommandBufferAllocator,
typename std::enable_if<std::is_same<typename B::value_type, CommandBuffer>::value, int>::type = 0> typename std::enable_if<std::is_same<typename B::value_type, CommandBuffer>::value, int>::type = 0>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer, CommandBufferAllocator>>::type
allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
CommandBufferAllocator & commandBufferAllocator, CommandBufferAllocator & commandBufferAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
@ -9334,7 +9336,7 @@ namespace VULKAN_HPP_NAMESPACE
template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>, template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
Optional<const AllocationCallbacks> allocator Optional<const AllocationCallbacks> allocator
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@ -9344,16 +9346,17 @@ namespace VULKAN_HPP_NAMESPACE
typename B = SwapchainKHRAllocator, typename B = SwapchainKHRAllocator,
typename std::enable_if<std::is_same<typename B::value_type, SwapchainKHR>::value, int>::type = 0> typename std::enable_if<std::is_same<typename B::value_type, SwapchainKHR>::value, int>::type = 0>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type typename ResultValueType<std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainKHRAllocator>>::type
createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
Optional<const AllocationCallbacks> allocator, Optional<const AllocationCallbacks> allocator,
SwapchainKHRAllocator & swapchainKHRAllocator, SwapchainKHRAllocator & swapchainKHRAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR( VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo, createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Optional<const AllocationCallbacks> allocator
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE # ifndef VULKAN_HPP_NO_SMART_HANDLE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename SwapchainKHRAllocator = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>> typename SwapchainKHRAllocator = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>>
@ -10700,23 +10703,25 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineAllocator = std::allocator<Pipeline>, template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesNV( VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, createRayTracingPipelinesNV(
ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PipelineAllocator = std::allocator<Pipeline>, template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PipelineAllocator, typename B = PipelineAllocator,
typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0> typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesNV( VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, createRayTracingPipelinesNV(
ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
Optional<const AllocationCallbacks> allocator, ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
PipelineAllocator & pipelineAllocator, Optional<const AllocationCallbacks> allocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; PipelineAllocator & pipelineAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<Pipeline> createRayTracingPipelineNV( VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createRayTracingPipelineNV(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
@ -11449,25 +11454,27 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename PipelineAllocator = std::allocator<Pipeline>, template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesKHR( VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, createRayTracingPipelinesKHR(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename PipelineAllocator = std::allocator<Pipeline>, template <typename PipelineAllocator = std::allocator<Pipeline>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = PipelineAllocator, typename B = PipelineAllocator,
typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0> typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesKHR( VULKAN_HPP_NODISCARD ResultValue<std::vector<VULKAN_HPP_NAMESPACE::Pipeline, PipelineAllocator>>
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, createRayTracingPipelinesKHR(
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
Optional<const AllocationCallbacks> allocator, ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
PipelineAllocator & pipelineAllocator, Optional<const AllocationCallbacks> allocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; PipelineAllocator & pipelineAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<Pipeline> createRayTracingPipelineKHR( VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Pipeline> createRayTracingPipelineKHR(
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo, const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo,