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

Generalize command generation for a specific type of commands

Browse Source 
Commands returning void, that get no non-const pointers but one or more const pointers or vectors are generalized into one function.
This commit is contained in:
asuessenbach 2022-01-13 12:37:34 +01:00
parent 8a25e6fd2c
commit 350a74f1e1
5 changed files with 594 additions and 454 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

441
VulkanHppGenerator.cpp
View File

@ -1970,20 +1970,6 @@ std::vector<size_t> VulkanHppGenerator::determineConstPointerParams( std::vector
return constPointerParams; return constPointerParams;
} }
std::set<size_t> VulkanHppGenerator::determineConstVoidPointerParams( std::vector<ParamData> const & params ) const
{
std::set<size_t> constVoidPointerParams;
for ( size_t i = 0; i < params.size(); i++ )
{
if ( params[i].type.isConstPointer() && params[i].type.type == "void" )
{
constVoidPointerParams.insert( i );
}
}
return constVoidPointerParams;
}
size_t VulkanHppGenerator::determineDefaultStartIndex( std::vector<ParamData> const & params, size_t VulkanHppGenerator::determineDefaultStartIndex( std::vector<ParamData> const & params,
std::set<size_t> const & skippedParams ) const std::set<size_t> const & skippedParams ) const
{ {
@ -2237,6 +2223,20 @@ std::map<size_t, size_t> VulkanHppGenerator::determineVectorParams( std::vector<
return vectorParams; return vectorParams;
} }
std::set<size_t> VulkanHppGenerator::determineVoidPointerParams( std::vector<ParamData> const & params ) const
{
std::set<size_t> voidPointerParams;
for ( size_t i = 0; i < params.size(); i++ )
{
if ( !params[i].type.isValue() && params[i].type.type == "void" )
{
voidPointerParams.insert( i );
}
}
return voidPointerParams;
}
void VulkanHppGenerator::distributeSecondLevelCommands( std::set<std::string> const & specialFunctions ) void VulkanHppGenerator::distributeSecondLevelCommands( std::set<std::string> const & specialFunctions )
{ {
// distribute commands from instance/device to second-level handles, like Queue, Event,... for RAII handles // distribute commands from instance/device to second-level handles, like Queue, Event,... for RAII handles
@ -2357,7 +2357,7 @@ std::string VulkanHppGenerator::generateArgumentListEnhanced( std::vector<ParamD
assert( !params[i].optional ); assert( !params[i].optional );
argumentList += ( templatedParams.find( i ) == templatedParams.end() ) argumentList += ( templatedParams.find( i ) == templatedParams.end() )
? ( composedType + " " + params[i].name ) ? ( composedType + " " + params[i].name )
: ( stripPrefix( params[i].name, "p" ) + "Type const & " + name ); : ( stripPrefix( params[i].name, "p" ) + "Type const & " + name );
} }
else if ( params[i].optional ) else if ( params[i].optional )
{ {
@ -2398,7 +2398,7 @@ std::string VulkanHppGenerator::generateArgumentListEnhanced( std::vector<ParamD
size_t pos = type.find( "void" ); size_t pos = type.find( "void" );
if ( pos != std::string::npos ) if ( pos != std::string::npos )
{ {
type.replace( pos, 4, "T" ); type.replace( pos, 4, stripPrefix( params[i].name, "p" ) + "Type" );
} }
argumentList += "ArrayProxy<" + type + "> const & " + name; argumentList += "ArrayProxy<" + type + "> const & " + name;
if ( params[i].optional && !definition ) if ( params[i].optional && !definition )
@ -2485,6 +2485,26 @@ std::string VulkanHppGenerator::generateArgumentListStandard( std::vector<ParamD
return argumentList; return argumentList;
} }
std::string VulkanHppGenerator::generateArgumentTemplates( std::vector<ParamData> const & params,
std::set<size_t> const & templatedParams,
bool complete ) const
{
std::string argumentTemplates;
if ( !templatedParams.empty() )
{
for ( auto t : templatedParams )
{
assert( beginsWith( params[t].name, "p" ) );
argumentTemplates += "typename " + stripPrefix( params[t].name, "p" ) + "Type, ";
}
if ( complete )
{
argumentTemplates = "\n template <" + stripPostfix( argumentTemplates, ", " ) + ">";
}
}
return argumentTemplates;
}
std::string VulkanHppGenerator::generateBitmask( std::map<std::string, BitmaskData>::const_iterator bitmaskIt ) const std::string VulkanHppGenerator::generateBitmask( std::map<std::string, BitmaskData>::const_iterator bitmaskIt ) const
{ {
auto bitmaskBitsIt = m_enums.find( bitmaskIt->second.requirements ); auto bitmaskBitsIt = m_enums.find( bitmaskIt->second.requirements );
@ -2927,7 +2947,7 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedValue( std::vector<P
argument = startLowerCase( stripPrefix( pointerIt->name, "p" ) ) + ".size()"; argument = startLowerCase( stripPrefix( pointerIt->name, "p" ) ) + ".size()";
if ( pointerIt->type.type == "void" ) if ( pointerIt->type.type == "void" )
{ {
argument += " * sizeof( T )"; argument += " * sizeof( " + stripPrefix( pointerIt->name, "p" ) + "Type )";
} }
} }
else else
@ -2957,14 +2977,14 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedValue( std::vector<P
argument = startLowerCase( stripPrefix( pointerIt->name, "p" ) ) + ".size()"; argument = startLowerCase( stripPrefix( pointerIt->name, "p" ) ) + ".size()";
if ( pointerIt->type.type == "void" ) if ( pointerIt->type.type == "void" )
{ {
argument += " * sizeof( T )"; argument += " * sizeof( " + stripPrefix( pointerIt->name, "p" ) + "Type )";
} }
} }
else else
{ {
if ( pointerIt->type.type == "void" ) if ( pointerIt->type.type == "void" )
{ {
argument = "sizeof( T )"; argument = "sizeof( " + stripPrefix( pointerIt->name, "p" ) + "Type )";
} }
else else
{ {
@ -3907,21 +3927,24 @@ std::string VulkanHppGenerator::generateCommandResultGetVector( std::string cons
std::set<size_t> skippedParams = std::set<size_t> skippedParams =
determineSkippedParams( commandData.params, initialSkipCount, vectorParams, { returnParam }, false ); determineSkippedParams( commandData.params, initialSkipCount, vectorParams, { returnParam }, false );
std::string argumentList = std::set<size_t> templatedParams = determineVoidPointerParams( commandData.params );
generateArgumentListEnhanced( commandData.params, skippedParams, {}, {}, definition, false, false, true ); assert( templatedParams.size() == 1 );
std::string argumentList = generateArgumentListEnhanced(
commandData.params, skippedParams, {}, templatedParams, definition, false, 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 returnType = generateReturnType( commandData.successCodes, "std::vector<T,Allocator>" ); std::string dataType = stripPrefix( commandData.params[*templatedParams.begin()].name, "p" ) + "Type";
std::string returnType = generateReturnType( commandData.successCodes, "std::vector<" + dataType + ",Allocator>" );
if ( definition ) if ( definition )
{ {
std::string const functionTemplate = std::string const functionTemplate =
R"( template <typename T, typename Allocator, typename Dispatch> R"( template <typename ${dataType}, typename Allocator, typename Dispatch>
${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 );
VULKAN_HPP_ASSERT( ${dataSize} % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( ${dataSize} % sizeof( ${dataType} ) == 0 );
std::vector<T,Allocator> ${dataName}( ${dataSize} / sizeof( T ) ); std::vector<${dataType},Allocator> ${dataName}( ${dataSize} / sizeof( ${dataType} ) );
Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) ); Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) );
return createResultValue( result, ${dataName}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} ); return createResultValue( result, ${dataName}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} );
})"; })";
@ -3936,6 +3959,7 @@ std::string VulkanHppGenerator::generateCommandResultGetVector( std::string cons
{ "commandName", commandName }, { "commandName", commandName },
{ "dataName", startLowerCase( stripPrefix( commandData.params[returnParam].name, "p" ) ) }, { "dataName", startLowerCase( stripPrefix( commandData.params[returnParam].name, "p" ) ) },
{ "dataSize", commandData.params[returnParam].len }, { "dataSize", commandData.params[returnParam].len },
{ "dataType", dataType },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
{ "returnType", returnType }, { "returnType", returnType },
{ "successCodeList", generateSuccessCodeList( commandData.successCodes ) }, { "successCodeList", generateSuccessCodeList( commandData.successCodes ) },
@ -3944,12 +3968,13 @@ std::string VulkanHppGenerator::generateCommandResultGetVector( std::string cons
else else
{ {
std::string const functionTemplate = std::string const functionTemplate =
R"( template <typename T, typename Allocator = std::allocator<T>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> R"( template <typename ${dataType}, typename Allocator = std::allocator<${dataType}>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
${nodiscard}${returnType} ${commandName}( ${argumentList} ) const;)"; ${nodiscard}${returnType} ${commandName}( ${argumentList} ) const;)";
return replaceWithMap( functionTemplate, return replaceWithMap( functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "commandName", commandName }, { "commandName", commandName },
{ "dataType", dataType },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
{ "returnType", returnType } } ); { "returnType", returnType } } );
} }
@ -4438,20 +4463,21 @@ std::string
std::set<size_t> skippedParams = std::set<size_t> skippedParams =
determineSkippedParams( commandData.params, initialSkipCount, vectorParams, { returnParam }, true ); determineSkippedParams( commandData.params, initialSkipCount, vectorParams, { returnParam }, true );
std::set<size_t> singularParams = determineSingularParams( returnParam, vectorParams ); std::set<size_t> singularParams = determineSingularParams( returnParam, vectorParams );
std::string argumentList = std::string argumentList = generateArgumentListEnhanced(
generateArgumentListEnhanced( commandData.params, skippedParams, {}, {}, definition, false, false, true ); commandData.params, skippedParams, {}, { returnParam }, 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 returnType = generateReturnType( commandData.successCodes, "T" ); std::string dataType = stripPrefix( commandData.params[returnParam].name, "p" ) + "Type";
std::string returnType = generateReturnType( commandData.successCodes, dataType );
if ( definition ) if ( definition )
{ {
std::string const functionTemplate = std::string const functionTemplate =
R"( template <typename T, typename Dispatch> R"( template <typename ${dataType}, typename Dispatch>
${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 );
T ${dataName}; ${dataType} ${dataName};
Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) ); Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) );
return createResultValue( result, ${dataName}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} ); return createResultValue( result, ${dataName}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} );
})"; })";
@ -4466,6 +4492,7 @@ std::string
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
{ "commandName", commandName }, { "commandName", commandName },
{ "dataName", startLowerCase( stripPrefix( commandData.params[returnParam].name, "p" ) ) }, { "dataName", startLowerCase( stripPrefix( commandData.params[returnParam].name, "p" ) ) },
{ "dataType", dataType },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
{ "returnType", returnType }, { "returnType", returnType },
{ "successCodeList", generateSuccessCodeList( commandData.successCodes ) }, { "successCodeList", generateSuccessCodeList( commandData.successCodes ) },
@ -4474,12 +4501,13 @@ std::string
else else
{ {
std::string const functionTemplate = std::string const functionTemplate =
R"( template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> R"( template <typename ${dataType}, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
${nodiscard}${returnType} ${commandName}( ${argumentList} ) const;)"; ${nodiscard}${returnType} ${commandName}( ${argumentList} ) const;)";
return replaceWithMap( functionTemplate, return replaceWithMap( functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "commandName", commandName }, { "commandName", commandName },
{ "dataType", dataType },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
{ "returnType", returnType } } ); { "returnType", returnType } } );
} }
@ -4861,7 +4889,8 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors0Ret
{ {
return generateCommandSetStandardOrEnhanced( return generateCommandSetStandardOrEnhanced(
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResult( name, commandData, initialSkipCount, definition, {} ) ); generateCommandResultSingleSuccessWithErrors0Return0Vector(
name, commandData, initialSkipCount, definition ) );
} }
else else
{ {
@ -4893,19 +4922,14 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors0Ret
std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const
{ {
std::set<size_t> skippedParams = determineSkippedParams( commandData.params, initialSkipCount, {}, {}, false ); std::set<size_t> skippedParams = determineSkippedParams( commandData.params, initialSkipCount, {}, {}, false );
std::set<size_t> templatedParams = determineConstVoidPointerParams( commandData.params ); std::set<size_t> templatedParams = determineVoidPointerParams( commandData.params );
assert( areDisjoint( skippedParams, templatedParams ) ); assert( areDisjoint( skippedParams, templatedParams ) );
std::string argumentList = generateArgumentListEnhanced( std::string argumentList = generateArgumentListEnhanced(
commandData.params, skippedParams, {}, templatedParams, definition, false, false, true ); commandData.params, skippedParams, {}, templatedParams, definition, false, 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 returnType = ( 1 < commandData.successCodes.size() ) ? "Result" : "typename ResultValueType<void>::type"; std::string returnType = ( 1 < commandData.successCodes.size() ) ? "Result" : "typename ResultValueType<void>::type";
std::string argumentTemplates; std::string argumentTemplates = generateArgumentTemplates( commandData.params, templatedParams, false );
for ( auto t : templatedParams )
{
assert( beginsWith( commandData.params[t].name, "p" ) );
argumentTemplates += "typename " + stripPrefix( commandData.params[t].name, "p" ) + "Type, ";
}
if ( definition ) if ( definition )
{ {
@ -5657,30 +5681,60 @@ std::string VulkanHppGenerator::generateCommandValue( std::string const & name,
return ""; return "";
} }
std::string VulkanHppGenerator::generateCommandVoid( std::string const & name, std::string VulkanHppGenerator::generateCommandVoid0Return( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
bool definition, bool definition ) const
std::map<size_t, size_t> const & vectorParams ) const {
std::map<size_t, size_t> vectorParams = determineVectorParams( commandData.params );
if ( vectorParams.empty() && determineConstPointerParams( commandData.params ).empty() )
{
return generateCommandSetStandard( generateCommandStandard( name, commandData, initialSkipCount, definition ) );
}
else
{
if ( std::find_if_not( vectorParams.begin(),
vectorParams.end(),
[&commandData]( std::pair<size_t, size_t> const & vpi )
{
return commandData.params[vpi.second].type.isValue() &&
( ( commandData.params[vpi.second].type.type == "uint32_t" ) ||
( commandData.params[vpi.second].type.type == "VkDeviceSize" ) );
} ) == vectorParams.end() )
{
// All the vectorParams have a counter by value, of type "uint32_t" or "VkDeviceSize"
return generateCommandSetStandardEnhanced(
definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandVoid0ReturnVectorOrPointer( name, commandData, initialSkipCount, definition, vectorParams ) );
}
}
return "";
}
std::string
VulkanHppGenerator::generateCommandVoid0ReturnVectorOrPointer( std::string const & name,
CommandData const & commandData,
size_t initialSkipCount,
bool definition,
std::map<size_t, size_t> const & vectorParams ) const
{ {
assert( ( commandData.returnType == "void" ) && commandData.successCodes.empty() && commandData.errorCodes.empty() ); assert( ( commandData.returnType == "void" ) && commandData.successCodes.empty() && commandData.errorCodes.empty() );
std::set<size_t> skippedParams = std::set<size_t> skippedParams =
determineSkippedParams( commandData.params, initialSkipCount, vectorParams, {}, false ); determineSkippedParams( commandData.params, initialSkipCount, vectorParams, {}, false );
std::string argumentList = std::set<size_t> templatedParams = determineVoidPointerParams( commandData.params );
generateArgumentListEnhanced( commandData.params, skippedParams, {}, {}, definition, false, false, true ); std::string argumentList = generateArgumentListEnhanced(
std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags ); commandData.params, skippedParams, {}, templatedParams, definition, false, false, true );
std::string typenameT = std::string argumentTemplates = generateArgumentTemplates( commandData.params, templatedParams, false );
( ( vectorParams.size() == 1 ) && ( commandData.params[vectorParams.begin()->first].type.type == "void" ) ) std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
? "typename T, "
: "";
std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParams ); std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParams );
std::string noexceptString = vectorSizeCheck.first ? "VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS" : "VULKAN_HPP_NOEXCEPT"; std::string noexceptString = vectorSizeCheck.first ? "VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS" : "VULKAN_HPP_NOEXCEPT";
if ( definition ) if ( definition )
{ {
std::string const functionTemplate = std::string const functionTemplate =
R"( template <${typenameT}typename Dispatch> R"( template <${argumentTemplates}typename Dispatch>
VULKAN_HPP_INLINE void ${className}${classSeparator}${commandName}( ${argumentList} ) const ${noexcept} VULKAN_HPP_INLINE void ${className}${classSeparator}${commandName}( ${argumentList} ) const ${noexcept}
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );${vectorSizeCheck} VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );${vectorSizeCheck}
@ -5690,13 +5744,14 @@ std::string VulkanHppGenerator::generateCommandVoid( std::string const &
return replaceWithMap( return replaceWithMap(
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", generateCallArgumentsEnhanced( commandData, initialSkipCount, false, {}, {}, false ) }, { "argumentTemplates", argumentTemplates },
{ "callArguments",
generateCallArgumentsEnhanced( commandData, initialSkipCount, false, {}, templatedParams, false ) },
{ "className", { "className",
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 },
{ "noexcept", noexceptString }, { "noexcept", noexceptString },
{ "typenameT", typenameT },
{ "vectorSizeCheck", { "vectorSizeCheck",
vectorSizeCheck.first vectorSizeCheck.first
? generateVectorSizeCheck( name, commandData, initialSkipCount, vectorSizeCheck.second, skippedParams ) ? generateVectorSizeCheck( name, commandData, initialSkipCount, vectorSizeCheck.second, skippedParams )
@ -5706,81 +5761,17 @@ std::string VulkanHppGenerator::generateCommandVoid( std::string const &
else else
{ {
std::string const functionTemplate = std::string const functionTemplate =
R"( template <${typenameT}typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> R"( template <${argumentTemplates}typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void ${commandName}( ${argumentList} ) const ${noexcept};)"; void ${commandName}( ${argumentList} ) const ${noexcept};)";
return replaceWithMap( functionTemplate, return replaceWithMap( functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "argumentTemplates", argumentTemplates },
{ "commandName", commandName }, { "commandName", commandName },
{ "noexcept", noexceptString }, { "noexcept", noexceptString } } );
{ "typenameT", typenameT } } );
} }
} }
std::string VulkanHppGenerator::generateCommandVoid0Return( std::string const & name,
CommandData const & commandData,
size_t initialSkipCount,
bool definition ) const
{
std::map<size_t, size_t> vectorParams = determineVectorParams( commandData.params );
switch ( vectorParams.size() )
{
case 0:
{
std::vector<size_t> constPointerParams = determineConstPointerParams( commandData.params );
if ( std::find_if( constPointerParams.begin(),
constPointerParams.end(),
[&commandData]( size_t idx )
{ return commandData.params[idx].type.type != "void"; } ) == constPointerParams.end() )
{
return generateCommandSetStandard(
generateCommandStandard( name, commandData, initialSkipCount, definition ) );
}
else
{
return generateCommandSetStandardEnhanced(
definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandVoid( name, commandData, initialSkipCount, definition, {} ) );
}
}
break;
case 1:
if ( commandData.params[vectorParams.begin()->second].type.isValue() )
{
if ( ( commandData.params[vectorParams.begin()->second].type.type == "uint32_t" ) ||
( commandData.params[vectorParams.begin()->second].type.type == "VkDeviceSize" ) )
{
// Note: no need to care about commandData.params[vectorParams.begin()->first].type.type !
return generateCommandSetStandardEnhanced(
definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandVoid( name, commandData, initialSkipCount, definition, vectorParams ) );
}
}
break;
default:
if ( std::find_if( vectorParams.begin(),
vectorParams.end(),
[&commandData]( std::pair<size_t, size_t> const & vpi )
{
return !commandData.params[vpi.second].type.isValue() ||
( commandData.params[vpi.second].type.type != "uint32_t" ) ||
( commandData.params[vpi.first].type.type == "void" );
} ) == vectorParams.end() )
{
// None of the vectorParams has a counter not by value, has a counter different from uint32_t,
// or has a data type void
return generateCommandSetStandardEnhanced(
definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandVoid( name, commandData, initialSkipCount, definition, vectorParams ) );
}
break;
}
return "";
}
std::string VulkanHppGenerator::generateCommandVoid1Return( std::string const & name, std::string VulkanHppGenerator::generateCommandVoid1Return( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
@ -8267,20 +8258,23 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE
assert( returnParamIndices.size() == 1 ); assert( returnParamIndices.size() == 1 );
std::set<size_t> skippedParams = std::set<size_t> skippedParams =
determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, returnParamIndices, true ); determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, returnParamIndices, true );
std::set<size_t> singularParams = determineSingularParams( returnParamIndices[0], vectorParams ); std::set<size_t> singularParams = determineSingularParams( returnParamIndices[0], vectorParams );
std::string argumentList = generateArgumentListEnhanced( std::set<size_t> templatedParams = determineVoidPointerParams( commandIt->second.params );
commandIt->second.params, skippedParams, singularParams, {}, definition, false, false, false ); assert( templatedParams.size() == 1 );
std::string argumentList = generateArgumentListEnhanced(
commandIt->second.params, skippedParams, singularParams, templatedParams, definition, false, false, false );
std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, templatedParams, true );
std::string commandName = std::string commandName =
stripPluralS( generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ) ); stripPluralS( generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ) );
std::string dataType = stripPrefix( commandIt->second.params[*templatedParams.begin()].name, "p" ) + "Type";
if ( definition ) if ( definition )
{ {
std::string const singularDefinitionTemplate = std::string const singularDefinitionTemplate =
R"( R"(${argumentTemplates}
template <typename T> VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, ${dataType}> ${className}::${commandName}( ${argumentList} ) const
VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, T> ${className}::${commandName}( ${argumentList} ) const
{ {
T ${dataName}; ${dataType} ${dataName};
Result result = static_cast<Result>( getDispatcher()->${vkCommand}( ${callArguments} ) ); Result result = static_cast<Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
if ( ${failureCheck} ) if ( ${failureCheck} )
{ {
@ -8297,26 +8291,27 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE
return replaceWithMap( return replaceWithMap(
singularDefinitionTemplate, singularDefinitionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "argumentTemplates", argumentTemplates },
{ "callArguments", callArguments }, { "callArguments", callArguments },
{ "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) }, { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
{ "commandName", commandName }, { "commandName", commandName },
{ "dataName", dataName }, { "dataName", dataName },
{ "dataType", dataType },
{ "failureCheck", generateFailureCheck( commandIt->second.successCodes ) }, { "failureCheck", generateFailureCheck( commandIt->second.successCodes ) },
{ "vkCommand", commandIt->first } } ); { "vkCommand", commandIt->first } } );
} }
else else
{ {
std::string const singularDeclarationTemplate = std::string const singularDeclarationTemplate =
R"( R"(${argumentTemplates}
template <typename T> VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, ${dataType}> ${commandName}( ${argumentList} ) const;
VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, T> ${commandName}( ${argumentList} ) const;
)"; )";
return replaceWithMap( singularDeclarationTemplate, return replaceWithMap( singularDeclarationTemplate,
{ { { "argumentList", argumentList },
{ "argumentList", argumentList }, { "argumentTemplates", argumentTemplates },
{ "commandName", commandName }, { "commandName", commandName },
} ); { "dataType", dataType } } );
} }
} }
@ -8329,19 +8324,22 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE
{ {
std::set<size_t> skippedParams = std::set<size_t> skippedParams =
determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, returnParamIndices, false ); determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, returnParamIndices, false );
std::string argumentList = std::set<size_t> templatedParams = determineVoidPointerParams( commandIt->second.params );
generateArgumentListEnhanced( commandIt->second.params, skippedParams, {}, {}, definition, false, false, false ); assert( templatedParams.size() == 1 );
std::string argumentList = generateArgumentListEnhanced(
commandIt->second.params, skippedParams, {}, templatedParams, definition, false, false, false );
std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, templatedParams, true );
std::string dataType = stripPrefix( commandIt->second.params[*templatedParams.begin()].name, "p" ) + "Type";
if ( definition ) if ( definition )
{ {
std::string const definitionTemplate = std::string const definitionTemplate =
R"( R"(${argumentTemplates}
template <typename T> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<${dataType}>> ${className}::${commandName}( ${argumentList} ) const
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<T>> ${className}::${commandName}( ${argumentList} ) const
{${functionPointerCheck} {${functionPointerCheck}
VULKAN_HPP_ASSERT( ${dataSize} % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( ${dataSize} % sizeof( ${dataType} ) == 0 );
std::vector<T> ${dataName}( ${dataSize} / sizeof( T ) ); std::vector<${dataType}> ${dataName}( ${dataSize} / sizeof( ${dataType} ) );
Result result = static_cast<Result>( getDispatcher()->${vkCommand}( ${callArguments} ) ); Result result = static_cast<Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
if ( ${failureCheck} ) if ( ${failureCheck} )
{ {
@ -8352,16 +8350,18 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE
)"; )";
std::string callArguments = std::string callArguments =
generateCallArgumentsEnhanced( commandIt->second, initialSkipCount, false, {}, {}, true ); generateCallArgumentsEnhanced( commandIt->second, initialSkipCount, false, {}, templatedParams, true );
std::string dataName = startLowerCase( stripPrefix( commandIt->second.params[returnParamIndices[0]].name, "p" ) ); std::string dataName = startLowerCase( stripPrefix( commandIt->second.params[returnParamIndices[0]].name, "p" ) );
return replaceWithMap( return replaceWithMap(
definitionTemplate, definitionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "argumentTemplates", argumentTemplates },
{ "callArguments", callArguments }, { "callArguments", callArguments },
{ "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) }, { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
{ "commandName", commandName }, { "commandName", commandName },
{ "dataName", dataName }, { "dataName", dataName },
{ "dataType", dataType },
{ "dataSize", commandIt->second.params[returnParamIndices[0]].len }, { "dataSize", commandIt->second.params[returnParamIndices[0]].len },
{ "failureCheck", generateFailureCheck( commandIt->second.successCodes ) }, { "failureCheck", generateFailureCheck( commandIt->second.successCodes ) },
{ "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) }, { "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
@ -8370,16 +8370,15 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE
else else
{ {
std::string const declarationTemplate = std::string const declarationTemplate =
R"( R"(${argumentTemplates}
template <typename T> VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<${dataType}>> ${commandName}( ${argumentList} ) const;
VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<T>> ${commandName}( ${argumentList} ) const;
)"; )";
return replaceWithMap( declarationTemplate, return replaceWithMap( declarationTemplate,
{ { { "argumentList", argumentList },
{ "argumentList", argumentList }, { "argumentTemplates", argumentTemplates },
{ "commandName", commandName }, { "commandName", commandName },
} ); { "dataType", dataType } } );
} }
} }
@ -8881,22 +8880,12 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
{ {
std::set<size_t> skippedParams = std::set<size_t> skippedParams =
determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, {}, false ); determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, {}, false );
std::set<size_t> templatedParams = determineConstVoidPointerParams( commandIt->second.params ); std::set<size_t> templatedParams = determineVoidPointerParams( commandIt->second.params );
assert( areDisjoint( skippedParams, templatedParams ) ); assert( areDisjoint( skippedParams, templatedParams ) );
std::string argumentList = generateArgumentListEnhanced( std::string argumentList = generateArgumentListEnhanced(
commandIt->second.params, skippedParams, {}, templatedParams, definition, false, false, false ); commandIt->second.params, skippedParams, {}, templatedParams, definition, false, false, false );
std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
std::string argumentTemplates; std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, templatedParams, true );
if ( !templatedParams.empty() )
{
argumentTemplates = "\n template <";
for ( auto t : templatedParams )
{
assert( beginsWith( commandIt->second.params[t].name, "p" ) );
argumentTemplates += "typename " + stripPrefix( commandIt->second.params[t].name, "p" ) + "Type, ";
}
argumentTemplates = stripPostfix( argumentTemplates, ", " ) + ">";
}
if ( definition ) if ( definition )
{ {
@ -9349,18 +9338,19 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, { returnParam }, true ); determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, { returnParam }, true );
std::set<size_t> singularParams = determineSingularParams( returnParam, vectorParams ); std::set<size_t> singularParams = determineSingularParams( returnParam, vectorParams );
std::string argumentList = generateArgumentListEnhanced( std::string argumentList = generateArgumentListEnhanced(
commandIt->second.params, skippedParams, singularParams, {}, definition, false, false, false ); commandIt->second.params, skippedParams, singularParams, { returnParam }, definition, false, false, false );
std::string commandName = std::string commandName =
stripPluralS( generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ) ); stripPluralS( generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ) );
std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, { returnParam }, true );
std::string dataType = stripPrefix( commandIt->second.params[returnParam].name, "p" ) + "Type";
if ( definition ) if ( definition )
{ {
std::string const singularDefinitionTemplate = std::string const singularDefinitionTemplate =
R"( R"(${argumentTemplates}
template <typename T> VULKAN_HPP_NODISCARD ${dataType} ${className}::${commandName}( ${argumentList} ) const
VULKAN_HPP_NODISCARD T ${className}::${commandName}( ${argumentList} ) const
{ {
T ${dataName}; ${dataType} ${dataName};
Result result = static_cast<Result>( getDispatcher()->${vkCommand}( ${callArguments} ) ); Result result = static_cast<Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
if ( ${failureCheck} ) if ( ${failureCheck} )
{ {
@ -9377,25 +9367,28 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
return replaceWithMap( return replaceWithMap(
singularDefinitionTemplate, singularDefinitionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "argumentTemplates", argumentTemplates },
{ "callArguments", callArguments }, { "callArguments", callArguments },
{ "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) }, { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
{ "commandName", commandName }, { "commandName", commandName },
{ "dataName", dataName }, { "dataName", dataName },
{ "dataType", dataType },
{ "failureCheck", generateFailureCheck( commandIt->second.successCodes ) }, { "failureCheck", generateFailureCheck( commandIt->second.successCodes ) },
{ "vkCommand", commandIt->first } } ); { "vkCommand", commandIt->first } } );
} }
else else
{ {
std::string const singularDeclarationTemplate = std::string const singularDeclarationTemplate =
R"( R"(${argumentTemplates}
template <typename T> VULKAN_HPP_NODISCARD ${dataType} ${commandName}( ${argumentList} ) const;
VULKAN_HPP_NODISCARD T ${commandName}( ${argumentList} ) const;
)"; )";
return replaceWithMap( singularDeclarationTemplate, return replaceWithMap( singularDeclarationTemplate,
{ {
{ "argumentList", argumentList }, { "argumentList", argumentList },
{ "argumentTemplates", argumentTemplates },
{ "commandName", commandName }, { "commandName", commandName },
{ "dataType", dataType },
} ); } );
} }
} }
@ -9409,19 +9402,20 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
{ {
std::set<size_t> skippedParams = std::set<size_t> skippedParams =
determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, { returnParam }, false ); determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, { returnParam }, false );
std::string argumentList = std::string argumentList = generateArgumentListEnhanced(
generateArgumentListEnhanced( commandIt->second.params, skippedParams, {}, {}, definition, false, false, false ); commandIt->second.params, skippedParams, {}, { returnParam }, definition, false, false, false );
std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, { returnParam }, true );
std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
std::string dataType = stripPrefix( commandIt->second.params[returnParam].name, "p" ) + "Type";
if ( definition ) if ( definition )
{ {
std::string const definitionTemplate = std::string const definitionTemplate =
R"( R"(${argumentTemplates}
template <typename T> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${dataType}> ${className}::${commandName}( ${argumentList} ) const
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> ${className}::${commandName}( ${argumentList} ) const
{${functionPointerCheck} {${functionPointerCheck}
VULKAN_HPP_ASSERT( ${dataSize} % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( ${dataSize} % sizeof( ${dataType} ) == 0 );
std::vector<T> ${dataName}( ${dataSize} / sizeof( T ) ); std::vector<${dataType}> ${dataName}( ${dataSize} / sizeof( ${dataType} ) );
Result result = static_cast<Result>( getDispatcher()->${vkCommand}( ${callArguments} ) ); Result result = static_cast<Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
if ( ${failureCheck} ) if ( ${failureCheck} )
{ {
@ -9438,10 +9432,12 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
return replaceWithMap( return replaceWithMap(
definitionTemplate, definitionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "argumentTemplates", argumentTemplates },
{ "callArguments", callArguments }, { "callArguments", callArguments },
{ "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) }, { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
{ "commandName", commandName }, { "commandName", commandName },
{ "dataName", dataName }, { "dataName", dataName },
{ "dataType", dataType },
{ "dataSize", commandIt->second.params[returnParam].len }, { "dataSize", commandIt->second.params[returnParam].len },
{ "failureCheck", generateFailureCheck( commandIt->second.successCodes ) }, { "failureCheck", generateFailureCheck( commandIt->second.successCodes ) },
{ "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) }, { "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
@ -9450,16 +9446,15 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
else else
{ {
std::string const declarationTemplate = std::string const declarationTemplate =
R"( R"(${argumentTemplates}
template <typename T> VULKAN_HPP_NODISCARD std::vector<${dataType}> ${commandName}( ${argumentList} ) const;
VULKAN_HPP_NODISCARD std::vector<T> ${commandName}( ${argumentList} ) const;
)"; )";
return replaceWithMap( declarationTemplate, return replaceWithMap( declarationTemplate,
{ { { "argumentList", argumentList },
{ "argumentList", argumentList }, { "argumentTemplates", argumentTemplates },
{ "commandName", commandName }, { "commandName", commandName },
} ); { "dataType", dataType } } );
} }
} }
@ -9865,28 +9860,26 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid0Return(
std::map<size_t, size_t> vectorParams = determineVectorParams( commandIt->second.params ); std::map<size_t, size_t> vectorParams = determineVectorParams( commandIt->second.params );
std::set<size_t> skippedParams = std::set<size_t> skippedParams =
determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, {}, false ); determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, {}, false );
std::string argumentList = std::set<size_t> templatedParams = determineVoidPointerParams( commandIt->second.params );
generateArgumentListEnhanced( commandIt->second.params, skippedParams, {}, {}, definition, false, false, false ); std::string argumentList = generateArgumentListEnhanced(
commandIt->second.params, skippedParams, {}, templatedParams, definition, false, false, false );
std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags );
std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParams ); std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParams );
std::string noexceptString = vectorSizeCheck.first ? "VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS" : "VULKAN_HPP_NOEXCEPT"; std::string noexceptString = vectorSizeCheck.first ? "VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS" : "VULKAN_HPP_NOEXCEPT";
std::string templateString = std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, templatedParams, true );
( ( vectorParams.size() == 1 ) && ( commandIt->second.params[vectorParams.begin()->first].type.type == "void" ) )
? "template <typename T>\n"
: "";
if ( definition ) if ( definition )
{ {
std::string const definitionTemplate = std::string const definitionTemplate =
R"( R"(${argumentTemplates}
${template}VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const ${noexcept} VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const ${noexcept}
{${functionPointerCheck}${vectorSizeCheck} {${functionPointerCheck}${vectorSizeCheck}
getDispatcher()->${vkCommand}( ${callArguments} ); getDispatcher()->${vkCommand}( ${callArguments} );
} }
)"; )";
std::string callArguments = std::string callArguments =
generateCallArgumentsEnhanced( commandIt->second, initialSkipCount, false, {}, {}, true ); generateCallArgumentsEnhanced( commandIt->second, initialSkipCount, false, {}, templatedParams, true );
std::string vectorSizeCheckString = std::string vectorSizeCheckString =
vectorSizeCheck.first vectorSizeCheck.first
? generateVectorSizeCheck( ? generateVectorSizeCheck(
@ -9896,27 +9889,27 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid0Return(
return replaceWithMap( return replaceWithMap(
definitionTemplate, definitionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "argumentTemplates", argumentTemplates },
{ "callArguments", callArguments }, { "callArguments", callArguments },
{ "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) }, { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
{ "commandName", commandName }, { "commandName", commandName },
{ "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) }, { "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
{ "noexcept", noexceptString }, { "noexcept", noexceptString },
{ "template", templateString },
{ "vectorSizeCheck", vectorSizeCheckString }, { "vectorSizeCheck", vectorSizeCheckString },
{ "vkCommand", commandIt->first } } ); { "vkCommand", commandIt->first } } );
} }
else else
{ {
std::string const declarationTemplate = std::string const declarationTemplate =
R"( R"(${argumentTemplates}
${template}void ${commandName}( ${argumentList} ) const ${noexcept}; void ${commandName}( ${argumentList} ) const ${noexcept};
)"; )";
return replaceWithMap( declarationTemplate, return replaceWithMap( declarationTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "argumentTemplates", argumentTemplates },
{ "commandName", commandName }, { "commandName", commandName },
{ "noexcept", noexceptString }, { "noexcept", noexceptString } } );
{ "template", templateString } } );
} }
} }
@ -12787,11 +12780,18 @@ std::string VulkanHppGenerator::generateVectorSizeCheck( std::string const &
std::string const assertTemplate = std::string const assertTemplate =
" VULKAN_HPP_ASSERT( ${zeroSizeCheck}${firstVectorName}.size() == ${secondVectorName}.size() );"; " VULKAN_HPP_ASSERT( ${zeroSizeCheck}${firstVectorName}.size() == ${secondVectorName}.size() );";
std::string const assertTemplateVoid =
" VULKAN_HPP_ASSERT( ${zeroSizeCheck}${firstVectorName}.size() * sizeof( ${firstDataType} ) == ${secondVectorName}.size() * sizeof( ${secondDataType} ) );";
std::string const throwTemplate = std::string const throwTemplate =
R"#( if ( ${zeroSizeCheck}${firstVectorName}.size() != ${secondVectorName}.size() ) R"#( if ( ${zeroSizeCheck}${firstVectorName}.size() != ${secondVectorName}.size() )
{ {
throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::${className}::${commandName}: ${firstVectorName}.size() != ${secondVectorName}.size()" ); throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::${className}::${commandName}: ${firstVectorName}.size() != ${secondVectorName}.size()" );
})#"; })#";
std::string const throwTemplateVoid =
R"#( if ( ${zeroSizeCheck}${firstVectorName}.size() * sizeof( ${firstDataType} ) != ${secondVectorName}.size() * sizeof( ${secondDataType} ) )
{
throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::${className}::${commandName}: ${firstVectorName}.size() * sizeof( ${firstDataType} ) != ${secondVectorName}.size() * sizeof( ${secondDataType} )" );
})#";
std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags ); std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags );
@ -12807,18 +12807,43 @@ std::string VulkanHppGenerator::generateVectorSizeCheck( std::string const &
{ {
std::string secondVectorName = startLowerCase( stripPrefix( commandData.params[cvm.second[i]].name, "p" ) ); std::string secondVectorName = startLowerCase( stripPrefix( commandData.params[cvm.second[i]].name, "p" ) );
bool withZeroSizeCheck = commandData.params[cvm.second[i]].optional && ( defaultStartIndex <= cvm.second[i] ); bool withZeroSizeCheck = commandData.params[cvm.second[i]].optional && ( defaultStartIndex <= cvm.second[i] );
assertions += if ( commandData.params[cvm.second[0]].type.type == "void" )
replaceWithMap( assertTemplate, {
{ { "firstVectorName", firstVectorName }, assert( commandData.params[cvm.second[i]].type.type == "void" );
{ "secondVectorName", secondVectorName }, std::string firstDataType = stripPrefix( commandData.params[cvm.second[0]].name, "p" ) + "Type";
{ "zeroSizeCheck", withZeroSizeCheck ? ( secondVectorName + ".empty() || " ) : "" } } ); std::string secondDataType = stripPrefix( commandData.params[cvm.second[i]].name, "p" ) + "Type";
throws += assertions +=
replaceWithMap( throwTemplate, replaceWithMap( assertTemplateVoid,
{ { "firstVectorName", firstVectorName }, { { "firstDataType", firstDataType },
{ "className", stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) }, { "firstVectorName", firstVectorName },
{ "commandName", commandName }, { "secondDataType", secondDataType },
{ "secondVectorName", secondVectorName }, { "secondVectorName", secondVectorName },
{ "zeroSizeCheck", withZeroSizeCheck ? ( "!" + secondVectorName + ".empty() && " ) : "" } } ); { "zeroSizeCheck", withZeroSizeCheck ? ( secondVectorName + ".empty() || " ) : "" } } );
throws += replaceWithMap(
throwTemplateVoid,
{ { "firstDataType", firstDataType },
{ "firstVectorName", firstVectorName },
{ "className", stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) },
{ "commandName", commandName },
{ "secondDataType", secondDataType },
{ "secondVectorName", secondVectorName },
{ "zeroSizeCheck", withZeroSizeCheck ? ( "!" + secondVectorName + ".empty() && " ) : "" } } );
}
else
{
assertions +=
replaceWithMap( assertTemplate,
{ { "firstVectorName", firstVectorName },
{ "secondVectorName", secondVectorName },
{ "zeroSizeCheck", withZeroSizeCheck ? ( secondVectorName + ".empty() || " ) : "" } } );
throws += replaceWithMap(
throwTemplate,
{ { "firstVectorName", firstVectorName },
{ "className", stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) },
{ "commandName", commandName },
{ "secondVectorName", secondVectorName },
{ "zeroSizeCheck", withZeroSizeCheck ? ( "!" + secondVectorName + ".empty() && " ) : "" } } );
}
if ( i + 1 < cvm.second.size() ) if ( i + 1 < cvm.second.size() )
{ {
assertions += "\n"; assertions += "\n";

15
VulkanHppGenerator.hpp
View File

@ -419,7 +419,6 @@ private:
bool containsFloatingPoints( std::vector<MemberData> const & members ) const; bool containsFloatingPoints( std::vector<MemberData> const & members ) const;
bool containsUnion( std::string const & type ) const; bool containsUnion( std::string const & type ) const;
std::vector<size_t> determineConstPointerParams( std::vector<ParamData> const & params ) const; std::vector<size_t> determineConstPointerParams( std::vector<ParamData> const & params ) const;
std::set<size_t> determineConstVoidPointerParams( std::vector<ParamData> const & params ) const;
size_t determineDefaultStartIndex( std::vector<ParamData> const & params, size_t determineDefaultStartIndex( std::vector<ParamData> const & params,
std::set<size_t> const & skippedParams ) const; std::set<size_t> const & skippedParams ) const;
size_t determineInitialSkipCount( std::string const & command ) const; size_t determineInitialSkipCount( std::string const & command ) const;
@ -436,6 +435,7 @@ private:
bool singular ) const; bool singular ) const;
std::string determineSubStruct( std::pair<std::string, StructureData> const & structure ) const; std::string determineSubStruct( std::pair<std::string, StructureData> const & structure ) const;
std::map<size_t, size_t> determineVectorParams( std::vector<ParamData> const & params ) const; std::map<size_t, size_t> determineVectorParams( std::vector<ParamData> const & params ) const;
std::set<size_t> determineVoidPointerParams( std::vector<ParamData> const & params ) const;
void distributeSecondLevelCommands( std::set<std::string> const & specialFunctions ); void distributeSecondLevelCommands( std::set<std::string> const & specialFunctions );
std::string findBaseName( std::string aliasName, std::map<std::string, EnumAliasData> const & aliases ) const; std::string findBaseName( std::string aliasName, std::map<std::string, EnumAliasData> const & aliases ) const;
std::vector<MemberData>::const_iterator findStructMemberIt( std::string const & name, std::vector<MemberData>::const_iterator findStructMemberIt( std::string const & name,
@ -452,6 +452,9 @@ private:
bool withDispatcher ) const; bool withDispatcher ) const;
std::string generateArgumentListStandard( std::vector<ParamData> const & params, std::string generateArgumentListStandard( std::vector<ParamData> const & params,
std::set<size_t> const & skippedParams ) const; std::set<size_t> const & skippedParams ) const;
std::string generateArgumentTemplates( std::vector<ParamData> const & params,
std::set<size_t> const & templatedParams,
bool complete ) const;
std::string generateBitmask( std::map<std::string, BitmaskData>::const_iterator bitmaskIt ) const; std::string generateBitmask( std::map<std::string, BitmaskData>::const_iterator bitmaskIt ) const;
std::string generateBitmasks( std::vector<RequireData> const & requireData, std::string generateBitmasks( std::vector<RequireData> const & requireData,
std::set<std::string> & listedBitmasks, std::set<std::string> & listedBitmasks,
@ -759,15 +762,15 @@ private:
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
bool definition ) const; bool definition ) const;
std::string generateCommandVoid( std::string const & name,
CommandData const & commandData,
size_t initialSkipCount,
bool definition,
std::map<size_t, size_t> const & vectorParamIndices ) const;
std::string generateCommandVoid0Return( std::string const & name, std::string generateCommandVoid0Return( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
bool definition ) const; bool definition ) const;
std::string generateCommandVoid0ReturnVectorOrPointer( std::string const & name,
CommandData const & commandData,
size_t initialSkipCount,
bool definition,
std::map<size_t, size_t> const & vectorParamIndices ) const;
std::string generateCommandVoid1Return( std::string const & name, std::string generateCommandVoid1Return( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,

217
vulkan/vulkan_funcs.hpp
View File

@ -2006,8 +2006,8 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
} }
template <typename T, typename Allocator, typename Dispatch> template <typename DataType, typename Allocator, typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<T, Allocator>> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<std::vector<DataType, Allocator>>
Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, Device::getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery, uint32_t firstQuery,
uint32_t queryCount, uint32_t queryCount,
@ -2017,13 +2017,13 @@ 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 );
VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
std::vector<T, Allocator> data( dataSize / sizeof( T ) ); std::vector<DataType, Allocator> data( dataSize / sizeof( DataType ) );
Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device, Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device,
static_cast<VkQueryPool>( queryPool ), static_cast<VkQueryPool>( queryPool ),
firstQuery, firstQuery,
queryCount, queryCount,
data.size() * sizeof( T ), data.size() * sizeof( DataType ),
reinterpret_cast<void *>( data.data() ), reinterpret_cast<void *>( data.data() ),
static_cast<VkDeviceSize>( stride ), static_cast<VkDeviceSize>( stride ),
static_cast<VkQueryResultFlags>( flags ) ) ); static_cast<VkQueryResultFlags>( flags ) ) );
@ -2033,8 +2033,8 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
} }
template <typename T, typename Dispatch> template <typename DataType, typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<T> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue<DataType>
Device::getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool queryPool, Device::getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery, uint32_t firstQuery,
uint32_t queryCount, uint32_t queryCount,
@ -2043,12 +2043,12 @@ 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 );
T data; DataType data;
Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device, Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device,
static_cast<VkQueryPool>( queryPool ), static_cast<VkQueryPool>( queryPool ),
firstQuery, firstQuery,
queryCount, queryCount,
sizeof( T ), sizeof( DataType ),
reinterpret_cast<void *>( &data ), reinterpret_cast<void *>( &data ),
static_cast<VkDeviceSize>( stride ), static_cast<VkDeviceSize>( stride ),
static_cast<VkQueryResultFlags>( flags ) ) ); static_cast<VkQueryResultFlags>( flags ) ) );
@ -5025,17 +5025,17 @@ namespace VULKAN_HPP_NAMESPACE
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename T, typename Dispatch> template <typename DataType, typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
ArrayProxy<const T> const & data, ArrayProxy<const DataType> const & data,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdUpdateBuffer( m_commandBuffer, d.vkCmdUpdateBuffer( m_commandBuffer,
static_cast<VkBuffer>( dstBuffer ), static_cast<VkBuffer>( dstBuffer ),
static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( dstOffset ),
data.size() * sizeof( T ), data.size() * sizeof( DataType ),
reinterpret_cast<const void *>( data.data() ) ); reinterpret_cast<const void *>( data.data() ) );
} }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -5404,11 +5404,11 @@ namespace VULKAN_HPP_NAMESPACE
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename T, typename Dispatch> template <typename ValuesType, typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout,
VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
uint32_t offset, uint32_t offset,
ArrayProxy<const T> const & values, ArrayProxy<const ValuesType> const & values,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
@ -5416,7 +5416,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkPipelineLayout>( layout ), static_cast<VkPipelineLayout>( layout ),
static_cast<VkShaderStageFlags>( stageFlags ), static_cast<VkShaderStageFlags>( stageFlags ),
offset, offset,
values.size() * sizeof( T ), values.size() * sizeof( ValuesType ),
reinterpret_cast<const void *>( values.data() ) ); reinterpret_cast<const void *>( values.data() ) );
} }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -6503,6 +6503,22 @@ namespace VULKAN_HPP_NAMESPACE
pData ); pData );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DataType, typename Dispatch>
VULKAN_HPP_INLINE void
Device::updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
DataType const & data,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkUpdateDescriptorSetWithTemplate( m_device,
static_cast<VkDescriptorSet>( descriptorSet ),
static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
reinterpret_cast<const void *>( &data ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
@ -11335,6 +11351,24 @@ namespace VULKAN_HPP_NAMESPACE
pData ); pData );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DataType, typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR(
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
VULKAN_HPP_NAMESPACE::PipelineLayout layout,
uint32_t set,
DataType const & data,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer,
static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
static_cast<VkPipelineLayout>( layout ),
set,
reinterpret_cast<const void *>( &data ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_conditional_rendering === //=== VK_EXT_conditional_rendering ===
template <typename Dispatch> template <typename Dispatch>
@ -11473,6 +11507,22 @@ namespace VULKAN_HPP_NAMESPACE
pData ); pData );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DataType, typename Dispatch>
VULKAN_HPP_INLINE void
Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
DataType const & data,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkUpdateDescriptorSetWithTemplateKHR( m_device,
static_cast<VkDescriptorSet>( descriptorSet ),
static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
reinterpret_cast<const void *>( &data ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_NV_clip_space_w_scaling === //=== VK_NV_clip_space_w_scaling ===
template <typename Dispatch> template <typename Dispatch>
@ -14000,9 +14050,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" ); VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" );
} }
template <typename T, typename Allocator, typename Dispatch> template <typename DataType, typename Allocator, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
Device::writeAccelerationStructuresPropertiesKHR( typename ResultValueType<std::vector<DataType, Allocator>>::type
Device::writeAccelerationStructuresPropertiesKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryType queryType,
size_t dataSize, size_t dataSize,
@ -14010,22 +14061,22 @@ 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 );
VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
std::vector<T, Allocator> data( dataSize / sizeof( T ) ); std::vector<DataType, Allocator> data( dataSize / sizeof( DataType ) );
Result result = static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR( Result result = static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR(
m_device, m_device,
accelerationStructures.size(), accelerationStructures.size(),
reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
static_cast<VkQueryType>( queryType ), static_cast<VkQueryType>( queryType ),
data.size() * sizeof( T ), data.size() * sizeof( DataType ),
reinterpret_cast<void *>( data.data() ), reinterpret_cast<void *>( data.data() ),
stride ) ); stride ) );
return createResultValue( return createResultValue(
result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" ); result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" );
} }
template <typename T, typename Dispatch> template <typename DataType, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
Device::writeAccelerationStructuresPropertyKHR( Device::writeAccelerationStructuresPropertyKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryType queryType,
@ -14033,13 +14084,13 @@ 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 );
T data; DataType data;
Result result = static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR( Result result = static_cast<Result>( d.vkWriteAccelerationStructuresPropertiesKHR(
m_device, m_device,
accelerationStructures.size(), accelerationStructures.size(),
reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
static_cast<VkQueryType>( queryType ), static_cast<VkQueryType>( queryType ),
sizeof( T ), sizeof( DataType ),
reinterpret_cast<void *>( &data ), reinterpret_cast<void *>( &data ),
stride ) ); stride ) );
return createResultValue( return createResultValue(
@ -15251,8 +15302,9 @@ namespace VULKAN_HPP_NAMESPACE
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" ); return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" );
} }
template <typename T, typename Allocator, typename Dispatch> template <typename DataType, typename Allocator, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<std::vector<DataType, Allocator>>::type
Device::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, Device::getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup, uint32_t firstGroup,
uint32_t groupCount, uint32_t groupCount,
@ -15260,32 +15312,32 @@ 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 );
VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
std::vector<T, Allocator> data( dataSize / sizeof( T ) ); std::vector<DataType, Allocator> data( dataSize / sizeof( DataType ) );
Result result = Result result =
static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device,
static_cast<VkPipeline>( pipeline ), static_cast<VkPipeline>( pipeline ),
firstGroup, firstGroup,
groupCount, groupCount,
data.size() * sizeof( T ), data.size() * sizeof( DataType ),
reinterpret_cast<void *>( data.data() ) ) ); reinterpret_cast<void *>( data.data() ) ) );
return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" ); return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" );
} }
template <typename T, typename Dispatch> template <typename DataType, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
Device::getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, Device::getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup, uint32_t firstGroup,
uint32_t groupCount, uint32_t groupCount,
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
T data; DataType data;
Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device,
static_cast<VkPipeline>( pipeline ), static_cast<VkPipeline>( pipeline ),
firstGroup, firstGroup,
groupCount, groupCount,
sizeof( T ), sizeof( DataType ),
reinterpret_cast<void *>( &data ) ) ); reinterpret_cast<void *>( &data ) ) );
return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleNV" ); return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleNV" );
} }
@ -15321,34 +15373,35 @@ namespace VULKAN_HPP_NAMESPACE
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" );
} }
template <typename T, typename Allocator, typename Dispatch> template <typename DataType, typename Allocator, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<std::vector<DataType, Allocator>>::type
Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
size_t dataSize, size_t dataSize,
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
std::vector<T, Allocator> data( dataSize / sizeof( T ) ); std::vector<DataType, Allocator> data( dataSize / sizeof( DataType ) );
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkGetAccelerationStructureHandleNV( m_device, d.vkGetAccelerationStructureHandleNV( m_device,
static_cast<VkAccelerationStructureNV>( accelerationStructure ), static_cast<VkAccelerationStructureNV>( accelerationStructure ),
data.size() * sizeof( T ), data.size() * sizeof( DataType ),
reinterpret_cast<void *>( data.data() ) ) ); reinterpret_cast<void *>( data.data() ) ) );
return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" );
} }
template <typename T, typename Dispatch> template <typename DataType, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, Device::getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
T data; DataType data;
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkGetAccelerationStructureHandleNV( m_device, d.vkGetAccelerationStructureHandleNV( m_device,
static_cast<VkAccelerationStructureNV>( accelerationStructure ), static_cast<VkAccelerationStructureNV>( accelerationStructure ),
sizeof( T ), sizeof( DataType ),
reinterpret_cast<void *>( &data ) ) ); reinterpret_cast<void *>( &data ) ) );
return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" );
} }
@ -15803,6 +15856,16 @@ namespace VULKAN_HPP_NAMESPACE
d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker ); d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename CheckpointMarkerType, typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( CheckpointMarkerType const & checkpointMarker,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdSetCheckpointNV( m_commandBuffer, reinterpret_cast<const void *>( &checkpointMarker ) );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void Queue::getCheckpointDataNV( uint32_t * pCheckpointDataCount, VULKAN_HPP_INLINE void Queue::getCheckpointDataNV( uint32_t * pCheckpointDataCount,
VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData, VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,
@ -19007,8 +19070,9 @@ namespace VULKAN_HPP_NAMESPACE
return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" ); return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" );
} }
template <typename T, typename Allocator, typename Dispatch> template <typename DataType, typename Allocator, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<std::vector<DataType, Allocator>>::type
Device::getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, Device::getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup, uint32_t firstGroup,
uint32_t groupCount, uint32_t groupCount,
@ -19016,33 +19080,33 @@ 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 );
VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
std::vector<T, Allocator> data( dataSize / sizeof( T ) ); std::vector<DataType, Allocator> data( dataSize / sizeof( DataType ) );
Result result = Result result =
static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device,
static_cast<VkPipeline>( pipeline ), static_cast<VkPipeline>( pipeline ),
firstGroup, firstGroup,
groupCount, groupCount,
data.size() * sizeof( T ), data.size() * sizeof( DataType ),
reinterpret_cast<void *>( data.data() ) ) ); reinterpret_cast<void *>( data.data() ) ) );
return createResultValue( return createResultValue(
result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" ); result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" );
} }
template <typename T, typename Dispatch> template <typename DataType, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
Device::getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, Device::getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup, uint32_t firstGroup,
uint32_t groupCount, uint32_t groupCount,
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
T data; DataType data;
Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device, Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesKHR( m_device,
static_cast<VkPipeline>( pipeline ), static_cast<VkPipeline>( pipeline ),
firstGroup, firstGroup,
groupCount, groupCount,
sizeof( T ), sizeof( DataType ),
reinterpret_cast<void *>( &data ) ) ); reinterpret_cast<void *>( &data ) ) );
return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleKHR" ); return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleKHR" );
} }
@ -19085,8 +19149,9 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" ); VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" );
} }
template <typename T, typename Allocator, typename Dispatch> template <typename DataType, typename Allocator, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<std::vector<T, Allocator>>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<std::vector<DataType, Allocator>>::type
Device::getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, Device::getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup, uint32_t firstGroup,
uint32_t groupCount, uint32_t groupCount,
@ -19094,34 +19159,34 @@ 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 );
VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
std::vector<T, Allocator> data( dataSize / sizeof( T ) ); std::vector<DataType, Allocator> data( dataSize / sizeof( DataType ) );
Result result = static_cast<Result>( Result result = static_cast<Result>(
d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device, d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device,
static_cast<VkPipeline>( pipeline ), static_cast<VkPipeline>( pipeline ),
firstGroup, firstGroup,
groupCount, groupCount,
data.size() * sizeof( T ), data.size() * sizeof( DataType ),
reinterpret_cast<void *>( data.data() ) ) ); reinterpret_cast<void *>( data.data() ) ) );
return createResultValue( return createResultValue(
result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" ); result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" );
} }
template <typename T, typename Dispatch> template <typename DataType, typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<T>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<DataType>::type
Device::getRayTracingCaptureReplayShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, Device::getRayTracingCaptureReplayShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup, uint32_t firstGroup,
uint32_t groupCount, uint32_t groupCount,
Dispatch const & d ) const Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
T data; DataType data;
Result result = Result result =
static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device, static_cast<Result>( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( m_device,
static_cast<VkPipeline>( pipeline ), static_cast<VkPipeline>( pipeline ),
firstGroup, firstGroup,
groupCount, groupCount,
sizeof( T ), sizeof( DataType ),
reinterpret_cast<void *>( &data ) ) ); reinterpret_cast<void *>( &data ) ) );
return createResultValue( return createResultValue(
result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandleKHR" ); result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandleKHR" );

111
vulkan/vulkan_handles.hpp
View File

@ -3520,10 +3520,10 @@ namespace VULKAN_HPP_NAMESPACE
const void * pData, const void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
ArrayProxy<const T> const & data, ArrayProxy<const DataType> const & data,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -3695,11 +3695,11 @@ namespace VULKAN_HPP_NAMESPACE
const void * pValues, const void * pValues,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename ValuesType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout,
VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
uint32_t offset, uint32_t offset,
ArrayProxy<const T> const & values, ArrayProxy<const ValuesType> const & values,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -4028,6 +4028,15 @@ namespace VULKAN_HPP_NAMESPACE
const void * pData, const void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT; VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
VULKAN_HPP_NAMESPACE::PipelineLayout layout,
uint32_t set,
DataType const & data,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_conditional_rendering === //=== VK_EXT_conditional_rendering ===
@ -4411,6 +4420,11 @@ namespace VULKAN_HPP_NAMESPACE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setCheckpointNV( const void * pCheckpointMarker, void setCheckpointNV( const void * pCheckpointMarker,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename CheckpointMarkerType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setCheckpointNV( CheckpointMarkerType const & checkpointMarker,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_INTEL_performance_query === //=== VK_INTEL_performance_query ===
@ -7958,10 +7972,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::DeviceSize stride,
VULKAN_HPP_NAMESPACE::QueryResultFlags flags, VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, template <typename DataType,
typename Allocator = std::allocator<T>, typename Allocator = std::allocator<DataType>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<std::vector<T, Allocator>> VULKAN_HPP_NODISCARD ResultValue<std::vector<DataType, Allocator>>
getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery, uint32_t firstQuery,
uint32_t queryCount, uint32_t queryCount,
@ -7969,8 +7983,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::DeviceSize stride,
VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD ResultValue<T> VULKAN_HPP_NODISCARD ResultValue<DataType>
getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool queryPool, getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
uint32_t firstQuery, uint32_t firstQuery,
uint32_t queryCount, uint32_t queryCount,
@ -9220,6 +9234,14 @@ namespace VULKAN_HPP_NAMESPACE
const void * pData, const void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT; VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
DataType const & data,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo, void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
@ -10065,6 +10087,14 @@ namespace VULKAN_HPP_NAMESPACE
const void * pData, const void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT; VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
DataType const & data,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_EXT_display_control === //=== VK_EXT_display_control ===
@ -10549,22 +10579,23 @@ namespace VULKAN_HPP_NAMESPACE
ArrayProxy<T> const & data, ArrayProxy<T> const & data,
size_t stride, size_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, template <typename DataType,
typename Allocator = std::allocator<T>, typename Allocator = std::allocator<DataType>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<DataType, Allocator>>::type
writeAccelerationStructuresPropertiesKHR( writeAccelerationStructuresPropertiesKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryType queryType,
size_t dataSize, size_t dataSize,
size_t stride, size_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type writeAccelerationStructuresPropertyKHR( VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<DataType>::type
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, writeAccelerationStructuresPropertyKHR(
VULKAN_HPP_NAMESPACE::QueryType queryType, ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
size_t stride, VULKAN_HPP_NAMESPACE::QueryType queryType,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; size_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@ -10939,17 +10970,17 @@ namespace VULKAN_HPP_NAMESPACE
uint32_t groupCount, uint32_t groupCount,
ArrayProxy<T> const & data, ArrayProxy<T> const & data,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, template <typename DataType,
typename Allocator = std::allocator<T>, typename Allocator = std::allocator<DataType>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<DataType, Allocator>>::type
getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup, uint32_t firstGroup,
uint32_t groupCount, uint32_t groupCount,
size_t dataSize, size_t dataSize,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<DataType>::type
getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup, uint32_t firstGroup,
uint32_t groupCount, uint32_t groupCount,
@ -10968,15 +10999,15 @@ namespace VULKAN_HPP_NAMESPACE
getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
ArrayProxy<T> const & data, ArrayProxy<T> const & data,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, template <typename DataType,
typename Allocator = std::allocator<T>, typename Allocator = std::allocator<DataType>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<DataType, Allocator>>::type
getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
size_t dataSize, size_t dataSize,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<DataType>::type
getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -11705,17 +11736,17 @@ namespace VULKAN_HPP_NAMESPACE
uint32_t groupCount, uint32_t groupCount,
ArrayProxy<T> const & data, ArrayProxy<T> const & data,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, template <typename DataType,
typename Allocator = std::allocator<T>, typename Allocator = std::allocator<DataType>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<DataType, Allocator>>::type
getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup, uint32_t firstGroup,
uint32_t groupCount, uint32_t groupCount,
size_t dataSize, size_t dataSize,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<DataType>::type
getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup, uint32_t firstGroup,
uint32_t groupCount, uint32_t groupCount,
@ -11739,18 +11770,18 @@ namespace VULKAN_HPP_NAMESPACE
ArrayProxy<T> const & data, ArrayProxy<T> const & data,
Dispatch const & d Dispatch const & d
VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, template <typename DataType,
typename Allocator = std::allocator<T>, typename Allocator = std::allocator<DataType>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<DataType, Allocator>>::type
getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup, uint32_t firstGroup,
uint32_t groupCount, uint32_t groupCount,
size_t dataSize, size_t dataSize,
Dispatch const & d Dispatch const & d
VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<DataType>::type
getRayTracingCaptureReplayShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline, getRayTracingCaptureReplayShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
uint32_t firstGroup, uint32_t firstGroup,
uint32_t groupCount, uint32_t groupCount,

264
vulkan/vulkan_raii.hpp
View File

@ -3550,15 +3550,15 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const; const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const;
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD std::vector<T> writeAccelerationStructuresPropertiesKHR( VULKAN_HPP_NODISCARD std::vector<DataType> writeAccelerationStructuresPropertiesKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryType queryType,
size_t dataSize, size_t dataSize,
size_t stride ) const; size_t stride ) const;
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD T writeAccelerationStructuresPropertyKHR( VULKAN_HPP_NODISCARD DataType writeAccelerationStructuresPropertyKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryType queryType,
size_t stride ) const; size_t stride ) const;
@ -4029,11 +4029,11 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_ray_tracing === //=== VK_NV_ray_tracing ===
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD std::vector<T> getHandle( size_t dataSize ) const; VULKAN_HPP_NODISCARD std::vector<DataType> getHandle( size_t dataSize ) const;
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD T getHandle() const; VULKAN_HPP_NODISCARD DataType getHandle() const;
private: private:
VULKAN_HPP_NAMESPACE::Device m_device = {}; VULKAN_HPP_NAMESPACE::Device m_device = {};
@ -4661,10 +4661,10 @@ namespace VULKAN_HPP_NAMESPACE
ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const
VULKAN_HPP_NOEXCEPT; VULKAN_HPP_NOEXCEPT;
template <typename T> template <typename DataType>
void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
ArrayProxy<const T> const & data ) const VULKAN_HPP_NOEXCEPT; ArrayProxy<const DataType> const & data ) const VULKAN_HPP_NOEXCEPT;
void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
@ -4742,11 +4742,11 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_NAMESPACE::QueryResultFlags flags
VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename T> template <typename ValuesType>
void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout,
VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
uint32_t offset, uint32_t offset,
ArrayProxy<const T> const & values ) const VULKAN_HPP_NOEXCEPT; ArrayProxy<const ValuesType> const & values ) const VULKAN_HPP_NOEXCEPT;
void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT; VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT;
@ -4905,10 +4905,11 @@ namespace VULKAN_HPP_NAMESPACE
uint32_t set, uint32_t set,
ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT; ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT;
template <typename DataType>
void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
VULKAN_HPP_NAMESPACE::PipelineLayout layout, VULKAN_HPP_NAMESPACE::PipelineLayout layout,
uint32_t set, uint32_t set,
const void * pData ) const VULKAN_HPP_NOEXCEPT; DataType const & data ) const VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_conditional_rendering === //=== VK_EXT_conditional_rendering ===
@ -5080,7 +5081,8 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_device_diagnostic_checkpoints === //=== VK_NV_device_diagnostic_checkpoints ===
void setCheckpointNV( const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT; template <typename CheckpointMarkerType>
void setCheckpointNV( CheckpointMarkerType const & checkpointMarker ) const VULKAN_HPP_NOEXCEPT;
//=== VK_INTEL_performance_query === //=== VK_INTEL_performance_query ===
@ -6026,13 +6028,15 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_VERSION_1_1 === //=== VK_VERSION_1_1 ===
template <typename DataType>
void updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, void updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
const void * pData ) const VULKAN_HPP_NOEXCEPT; DataType const & data ) const VULKAN_HPP_NOEXCEPT;
//=== VK_KHR_descriptor_update_template === //=== VK_KHR_descriptor_update_template ===
template <typename DataType>
void updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, void updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
const void * pData ) const VULKAN_HPP_NOEXCEPT; DataType const & data ) const VULKAN_HPP_NOEXCEPT;
private: private:
VULKAN_HPP_NAMESPACE::Device m_device = {}; VULKAN_HPP_NAMESPACE::Device m_device = {};
@ -7751,32 +7755,31 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_ray_tracing === //=== VK_NV_ray_tracing ===
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD std::vector<T> VULKAN_HPP_NODISCARD std::vector<DataType>
getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const; getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const;
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD T getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const; VULKAN_HPP_NODISCARD DataType getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const;
void compileDeferredNV( uint32_t shader ) const; void compileDeferredNV( uint32_t shader ) const;
//=== VK_KHR_ray_tracing_pipeline === //=== VK_KHR_ray_tracing_pipeline ===
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD std::vector<T> VULKAN_HPP_NODISCARD std::vector<DataType>
getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const; getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const;
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD T getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const; VULKAN_HPP_NODISCARD DataType getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const;
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD std::vector<T> getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup, VULKAN_HPP_NODISCARD std::vector<DataType> getRayTracingCaptureReplayShaderGroupHandlesKHR(
uint32_t groupCount, uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const;
size_t dataSize ) const;
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD T getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup, VULKAN_HPP_NODISCARD DataType getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup,
uint32_t groupCount ) const; uint32_t groupCount ) const;
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getRayTracingShaderGroupStackSizeKHR(
uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT; uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT;
@ -8239,16 +8242,16 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_VERSION_1_0 === //=== VK_VERSION_1_0 ===
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<T>> VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<DataType>>
getResults( uint32_t firstQuery, getResults( uint32_t firstQuery,
uint32_t queryCount, uint32_t queryCount,
size_t dataSize, size_t dataSize,
VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::DeviceSize stride,
VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, T> VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, DataType>
getResult( uint32_t firstQuery, getResult( uint32_t firstQuery,
uint32_t queryCount, uint32_t queryCount,
VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::DeviceSize stride,
@ -10410,22 +10413,22 @@ namespace VULKAN_HPP_NAMESPACE
return VULKAN_HPP_RAII_NAMESPACE::QueryPool( *this, createInfo, allocator ); return VULKAN_HPP_RAII_NAMESPACE::QueryPool( *this, createInfo, allocator );
} }
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<T>> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<DataType>>
QueryPool::getResults( uint32_t firstQuery, QueryPool::getResults( uint32_t firstQuery,
uint32_t queryCount, uint32_t queryCount,
size_t dataSize, size_t dataSize,
VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::DeviceSize stride,
VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const
{ {
VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
std::vector<T> data( dataSize / sizeof( T ) ); std::vector<DataType> data( dataSize / sizeof( DataType ) );
Result result = Result result =
static_cast<Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ), static_cast<Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
static_cast<VkQueryPool>( m_queryPool ), static_cast<VkQueryPool>( m_queryPool ),
firstQuery, firstQuery,
queryCount, queryCount,
data.size() * sizeof( T ), data.size() * sizeof( DataType ),
reinterpret_cast<void *>( data.data() ), reinterpret_cast<void *>( data.data() ),
static_cast<VkDeviceSize>( stride ), static_cast<VkDeviceSize>( stride ),
static_cast<VkQueryResultFlags>( flags ) ) ); static_cast<VkQueryResultFlags>( flags ) ) );
@ -10437,20 +10440,20 @@ namespace VULKAN_HPP_NAMESPACE
return std::make_pair( result, data ); return std::make_pair( result, data );
} }
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, T> VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, DataType>
QueryPool::getResult( uint32_t firstQuery, QueryPool::getResult( uint32_t firstQuery,
uint32_t queryCount, uint32_t queryCount,
VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::DeviceSize stride,
VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const
{ {
T data; DataType data;
Result result = Result result =
static_cast<Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ), static_cast<Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
static_cast<VkQueryPool>( m_queryPool ), static_cast<VkQueryPool>( m_queryPool ),
firstQuery, firstQuery,
queryCount, queryCount,
sizeof( T ), sizeof( DataType ),
reinterpret_cast<void *>( &data ), reinterpret_cast<void *>( &data ),
static_cast<VkDeviceSize>( stride ), static_cast<VkDeviceSize>( stride ),
static_cast<VkQueryResultFlags>( flags ) ) ); static_cast<VkQueryResultFlags>( flags ) ) );
@ -11000,15 +11003,16 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) ); reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
} }
template <typename T> template <typename DataType>
VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_INLINE void
VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
ArrayProxy<const T> const & data ) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
ArrayProxy<const DataType> const & data ) const VULKAN_HPP_NOEXCEPT
{ {
getDispatcher()->vkCmdUpdateBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), getDispatcher()->vkCmdUpdateBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
static_cast<VkBuffer>( dstBuffer ), static_cast<VkBuffer>( dstBuffer ),
static_cast<VkDeviceSize>( dstOffset ), static_cast<VkDeviceSize>( dstOffset ),
data.size() * sizeof( T ), data.size() * sizeof( DataType ),
reinterpret_cast<const void *>( data.data() ) ); reinterpret_cast<const void *>( data.data() ) );
} }
@ -11197,17 +11201,18 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkQueryResultFlags>( flags ) ); static_cast<VkQueryResultFlags>( flags ) );
} }
template <typename T> template <typename ValuesType>
VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, VULKAN_HPP_INLINE void
VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout,
uint32_t offset, VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
ArrayProxy<const T> const & values ) const VULKAN_HPP_NOEXCEPT uint32_t offset,
ArrayProxy<const ValuesType> const & values ) const VULKAN_HPP_NOEXCEPT
{ {
getDispatcher()->vkCmdPushConstants( static_cast<VkCommandBuffer>( m_commandBuffer ), getDispatcher()->vkCmdPushConstants( static_cast<VkCommandBuffer>( m_commandBuffer ),
static_cast<VkPipelineLayout>( layout ), static_cast<VkPipelineLayout>( layout ),
static_cast<VkShaderStageFlags>( stageFlags ), static_cast<VkShaderStageFlags>( stageFlags ),
offset, offset,
values.size() * sizeof( T ), values.size() * sizeof( ValuesType ),
reinterpret_cast<const void *>( values.data() ) ); reinterpret_cast<const void *>( values.data() ) );
} }
@ -11639,15 +11644,16 @@ namespace VULKAN_HPP_NAMESPACE
return VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate( *this, createInfo, allocator ); return VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate( *this, createInfo, allocator );
} }
template <typename DataType>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
DescriptorSet::updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DescriptorSet::updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
const void * pData ) const VULKAN_HPP_NOEXCEPT DataType const & data ) const VULKAN_HPP_NOEXCEPT
{ {
getDispatcher()->vkUpdateDescriptorSetWithTemplate( getDispatcher()->vkUpdateDescriptorSetWithTemplate(
static_cast<VkDevice>( m_device ), static_cast<VkDevice>( m_device ),
static_cast<VkDescriptorSet>( m_descriptorSet ), static_cast<VkDescriptorSet>( m_descriptorSet ),
static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
pData ); reinterpret_cast<const void *>( &data ) );
} }
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties
@ -13704,11 +13710,12 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) ); reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) );
} }
template <typename DataType>
VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR(
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
VULKAN_HPP_NAMESPACE::PipelineLayout layout, VULKAN_HPP_NAMESPACE::PipelineLayout layout,
uint32_t set, uint32_t set,
const void * pData ) const VULKAN_HPP_NOEXCEPT DataType const & data ) const VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT( VULKAN_HPP_ASSERT(
getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR && getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR &&
@ -13719,7 +13726,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
static_cast<VkPipelineLayout>( layout ), static_cast<VkPipelineLayout>( layout ),
set, set,
pData ); reinterpret_cast<const void *>( &data ) );
} }
//=== VK_EXT_conditional_rendering === //=== VK_EXT_conditional_rendering ===
@ -13771,9 +13778,10 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
} }
template <typename DataType>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
DescriptorSet::updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DescriptorSet::updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
const void * pData ) const VULKAN_HPP_NOEXCEPT DataType const & data ) const VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT( VULKAN_HPP_ASSERT(
getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR && getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR &&
@ -13783,7 +13791,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkDevice>( m_device ), static_cast<VkDevice>( m_device ),
static_cast<VkDescriptorSet>( m_descriptorSet ), static_cast<VkDescriptorSet>( m_descriptorSet ),
static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
pData ); reinterpret_cast<const void *>( &data ) );
} }
//=== VK_NV_clip_space_w_scaling === //=== VK_NV_clip_space_w_scaling ===
@ -14976,8 +14984,8 @@ namespace VULKAN_HPP_NAMESPACE
return result; return result;
} }
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> Device::writeAccelerationStructuresPropertiesKHR( VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> Device::writeAccelerationStructuresPropertiesKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryType queryType,
size_t dataSize, size_t dataSize,
@ -14987,14 +14995,14 @@ namespace VULKAN_HPP_NAMESPACE
getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR && getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR &&
"Function <vkWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); "Function <vkWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
std::vector<T> data( dataSize / sizeof( T ) ); std::vector<DataType> data( dataSize / sizeof( DataType ) );
Result result = static_cast<Result>( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( Result result = static_cast<Result>( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR(
static_cast<VkDevice>( m_device ), static_cast<VkDevice>( m_device ),
accelerationStructures.size(), accelerationStructures.size(),
reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
static_cast<VkQueryType>( queryType ), static_cast<VkQueryType>( queryType ),
data.size() * sizeof( T ), data.size() * sizeof( DataType ),
reinterpret_cast<void *>( data.data() ), reinterpret_cast<void *>( data.data() ),
stride ) ); stride ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
@ -15005,19 +15013,19 @@ namespace VULKAN_HPP_NAMESPACE
return data; return data;
} }
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD T Device::writeAccelerationStructuresPropertyKHR( VULKAN_HPP_NODISCARD DataType Device::writeAccelerationStructuresPropertyKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
VULKAN_HPP_NAMESPACE::QueryType queryType, VULKAN_HPP_NAMESPACE::QueryType queryType,
size_t stride ) const size_t stride ) const
{ {
T data; DataType data;
Result result = static_cast<Result>( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( Result result = static_cast<Result>( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR(
static_cast<VkDevice>( m_device ), static_cast<VkDevice>( m_device ),
accelerationStructures.size(), accelerationStructures.size(),
reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
static_cast<VkQueryType>( queryType ), static_cast<VkQueryType>( queryType ),
sizeof( T ), sizeof( DataType ),
reinterpret_cast<void *>( &data ), reinterpret_cast<void *>( &data ),
stride ) ); stride ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
@ -15482,22 +15490,22 @@ namespace VULKAN_HPP_NAMESPACE
return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, pipelineCache, createInfo, allocator ); return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, pipelineCache, createInfo, allocator );
} }
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType>
Pipeline::getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const Pipeline::getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const
{ {
VULKAN_HPP_ASSERT( VULKAN_HPP_ASSERT(
getDispatcher()->vkGetRayTracingShaderGroupHandlesNV && getDispatcher()->vkGetRayTracingShaderGroupHandlesNV &&
"Function <vkGetRayTracingShaderGroupHandlesNV> needs extension <VK_NV_ray_tracing> enabled!" ); "Function <vkGetRayTracingShaderGroupHandlesNV> needs extension <VK_NV_ray_tracing> enabled!" );
VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
std::vector<T> data( dataSize / sizeof( T ) ); std::vector<DataType> data( dataSize / sizeof( DataType ) );
Result result = static_cast<Result>( Result result = static_cast<Result>(
getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ), getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ),
static_cast<VkPipeline>( m_pipeline ), static_cast<VkPipeline>( m_pipeline ),
firstGroup, firstGroup,
groupCount, groupCount,
data.size() * sizeof( T ), data.size() * sizeof( DataType ),
reinterpret_cast<void *>( data.data() ) ) ); reinterpret_cast<void *>( data.data() ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
@ -15506,16 +15514,17 @@ namespace VULKAN_HPP_NAMESPACE
return data; return data;
} }
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD T Pipeline::getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const VULKAN_HPP_NODISCARD DataType Pipeline::getRayTracingShaderGroupHandleNV( uint32_t firstGroup,
uint32_t groupCount ) const
{ {
T data; DataType data;
Result result = static_cast<Result>( Result result = static_cast<Result>(
getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ), getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ),
static_cast<VkPipeline>( m_pipeline ), static_cast<VkPipeline>( m_pipeline ),
firstGroup, firstGroup,
groupCount, groupCount,
sizeof( T ), sizeof( DataType ),
reinterpret_cast<void *>( &data ) ) ); reinterpret_cast<void *>( &data ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
@ -15524,18 +15533,19 @@ namespace VULKAN_HPP_NAMESPACE
return data; return data;
} }
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> AccelerationStructureNV::getHandle( size_t dataSize ) const VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType>
AccelerationStructureNV::getHandle( size_t dataSize ) const
{ {
VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureHandleNV && VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureHandleNV &&
"Function <vkGetAccelerationStructureHandleNV> needs extension <VK_NV_ray_tracing> enabled!" ); "Function <vkGetAccelerationStructureHandleNV> needs extension <VK_NV_ray_tracing> enabled!" );
VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
std::vector<T> data( dataSize / sizeof( T ) ); std::vector<DataType> data( dataSize / sizeof( DataType ) );
Result result = static_cast<Result>( getDispatcher()->vkGetAccelerationStructureHandleNV( Result result = static_cast<Result>( getDispatcher()->vkGetAccelerationStructureHandleNV(
static_cast<VkDevice>( m_device ), static_cast<VkDevice>( m_device ),
static_cast<VkAccelerationStructureNV>( m_accelerationStructure ), static_cast<VkAccelerationStructureNV>( m_accelerationStructure ),
data.size() * sizeof( T ), data.size() * sizeof( DataType ),
reinterpret_cast<void *>( data.data() ) ) ); reinterpret_cast<void *>( data.data() ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
@ -15544,14 +15554,14 @@ namespace VULKAN_HPP_NAMESPACE
return data; return data;
} }
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD T AccelerationStructureNV::getHandle() const VULKAN_HPP_NODISCARD DataType AccelerationStructureNV::getHandle() const
{ {
T data; DataType data;
Result result = static_cast<Result>( getDispatcher()->vkGetAccelerationStructureHandleNV( Result result = static_cast<Result>( getDispatcher()->vkGetAccelerationStructureHandleNV(
static_cast<VkDevice>( m_device ), static_cast<VkDevice>( m_device ),
static_cast<VkAccelerationStructureNV>( m_accelerationStructure ), static_cast<VkAccelerationStructureNV>( m_accelerationStructure ),
sizeof( T ), sizeof( DataType ),
reinterpret_cast<void *>( &data ) ) ); reinterpret_cast<void *>( &data ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
@ -15868,13 +15878,16 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_device_diagnostic_checkpoints === //=== VK_NV_device_diagnostic_checkpoints ===
VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT template <typename CheckpointMarkerType>
VULKAN_HPP_INLINE void
CommandBuffer::setCheckpointNV( CheckpointMarkerType const & checkpointMarker ) const VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT( VULKAN_HPP_ASSERT(
getDispatcher()->vkCmdSetCheckpointNV && getDispatcher()->vkCmdSetCheckpointNV &&
"Function <vkCmdSetCheckpointNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!" ); "Function <vkCmdSetCheckpointNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!" );
getDispatcher()->vkCmdSetCheckpointNV( static_cast<VkCommandBuffer>( m_commandBuffer ), pCheckpointMarker ); getDispatcher()->vkCmdSetCheckpointNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
reinterpret_cast<const void *>( &checkpointMarker ) );
} }
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV>
@ -17301,22 +17314,22 @@ namespace VULKAN_HPP_NAMESPACE
return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, deferredOperation, pipelineCache, createInfo, allocator ); return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, deferredOperation, pipelineCache, createInfo, allocator );
} }
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType>
Pipeline::getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const Pipeline::getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const
{ {
VULKAN_HPP_ASSERT( VULKAN_HPP_ASSERT(
getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR && getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR &&
"Function <vkGetRayTracingShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" ); "Function <vkGetRayTracingShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
std::vector<T> data( dataSize / sizeof( T ) ); std::vector<DataType> data( dataSize / sizeof( DataType ) );
Result result = static_cast<Result>( Result result = static_cast<Result>(
getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ), getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
static_cast<VkPipeline>( m_pipeline ), static_cast<VkPipeline>( m_pipeline ),
firstGroup, firstGroup,
groupCount, groupCount,
data.size() * sizeof( T ), data.size() * sizeof( DataType ),
reinterpret_cast<void *>( data.data() ) ) ); reinterpret_cast<void *>( data.data() ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
@ -17325,16 +17338,17 @@ namespace VULKAN_HPP_NAMESPACE
return data; return data;
} }
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD T Pipeline::getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const VULKAN_HPP_NODISCARD DataType Pipeline::getRayTracingShaderGroupHandleKHR( uint32_t firstGroup,
uint32_t groupCount ) const
{ {
T data; DataType data;
Result result = static_cast<Result>( Result result = static_cast<Result>(
getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ), getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
static_cast<VkPipeline>( m_pipeline ), static_cast<VkPipeline>( m_pipeline ),
firstGroup, firstGroup,
groupCount, groupCount,
sizeof( T ), sizeof( DataType ),
reinterpret_cast<void *>( &data ) ) ); reinterpret_cast<void *>( &data ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
@ -17343,22 +17357,24 @@ namespace VULKAN_HPP_NAMESPACE
return data; return data;
} }
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType>
uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup,
uint32_t groupCount,
size_t dataSize ) const
{ {
VULKAN_HPP_ASSERT( VULKAN_HPP_ASSERT(
getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR &&
"Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" ); "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
std::vector<T> data( dataSize / sizeof( T ) ); std::vector<DataType> data( dataSize / sizeof( DataType ) );
Result result = static_cast<Result>( Result result = static_cast<Result>(
getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ), getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
static_cast<VkPipeline>( m_pipeline ), static_cast<VkPipeline>( m_pipeline ),
firstGroup, firstGroup,
groupCount, groupCount,
data.size() * sizeof( T ), data.size() * sizeof( DataType ),
reinterpret_cast<void *>( data.data() ) ) ); reinterpret_cast<void *>( data.data() ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {
@ -17368,17 +17384,17 @@ namespace VULKAN_HPP_NAMESPACE
return data; return data;
} }
template <typename T> template <typename DataType>
VULKAN_HPP_NODISCARD T Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup, VULKAN_HPP_NODISCARD DataType Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup,
uint32_t groupCount ) const uint32_t groupCount ) const
{ {
T data; DataType data;
Result result = static_cast<Result>( Result result = static_cast<Result>(
getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ), getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
static_cast<VkPipeline>( m_pipeline ), static_cast<VkPipeline>( m_pipeline ),
firstGroup, firstGroup,
groupCount, groupCount,
sizeof( T ), sizeof( DataType ),
reinterpret_cast<void *>( &data ) ) ); reinterpret_cast<void *>( &data ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{ {