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

Merge pull request #746 from asuessenbach/refactor

Browse Source 
refactor more functions into the simple void case.
This commit is contained in:
Andreas Süßenbach 2020-09-24 14:24:36 +02:00 committed by GitHub
commit 3c2966157c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 336 additions and 332 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

272
VulkanHppGenerator.cpp
View File

@ -1225,19 +1225,17 @@ void VulkanHppGenerator::appendCommand( std::string & str,
{ {
bool appendedFunction = false; bool appendedFunction = false;
std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices( commandData.params ); std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices( commandData.params );
switch ( vectorParamIndices.size() )
{
case 0:
{
// no vector parameter
std::vector<size_t> nonConstPointerParamIndices = determineNonConstPointerParamIndices( commandData.params ); std::vector<size_t> nonConstPointerParamIndices = determineNonConstPointerParamIndices( commandData.params );
if ( nonConstPointerParamIndices.empty() ) if ( nonConstPointerParamIndices.empty() )
{ {
// no return parameter // no return parameter
std::vector<size_t> constPointerParamIndices = determineConstPointerParamIndices( commandData.params ); std::vector<size_t> constPointerParamIndices = determineConstPointerParamIndices( commandData.params );
if ( constPointerParamIndices.empty() ) if ( vectorParamIndices.empty() &&
std::find_if( constPointerParamIndices.begin(), constPointerParamIndices.end(), [&commandData]( size_t idx ) {
return commandData.params[idx].type.type != "void";
} ) == constPointerParamIndices.end() )
{ {
// no const-pointers in // no vector paramter and no non-void const-pointer
if ( commandData.returnType == "void" ) if ( commandData.returnType == "void" )
{ {
// void functions // void functions
@ -1247,34 +1245,38 @@ void VulkanHppGenerator::appendCommand( std::string & str,
} }
else else
{ {
// with const-pointer(s), // with const-pointers that might be changed to by-reference arguments
switch ( commandData.successCodes.size() ) if ( commandData.returnType == "void" )
{ {
case 0: appendCommandSimpleVoid( str, name, commandData, definition, vectorParamIndices );
// no success codes at all
if ( ( commandData.returnType == "void" ) &&
std::find_if(
constPointerParamIndices.begin(), constPointerParamIndices.end(), [&commandData]( size_t idx ) {
return commandData.params[idx].type.type == "void";
} ) == constPointerParamIndices.end() )
{
// command returns void, and the const pointer(s) are void-pointers and thus can't be change from
// by-pointer to by-reference
appendCommandSimpleVoid( str, name, commandData, definition );
appendedFunction = true; appendedFunction = true;
} }
break; else if ( vectorParamIndices.empty() && ( commandData.returnType == "VkResult" ) &&
case 1: ( commandData.successCodes.size() == 1 ) )
// just one success code {
// returns VkResult, but there's just one success code
appendCommandSimple( str, name, commandData, definition ); appendCommandSimple( str, name, commandData, definition );
appendedFunction = true; appendedFunction = true;
break; }
default: break; else if ( ( vectorParamIndices.size() == 2 ) && ( vectorParamIndices.begin()->second != INVALID_INDEX ) &&
( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second ) )
{
assert( commandData.params[vectorParamIndices.begin()->second].type.isValue() );
if ( commandData.params[vectorParamIndices.begin()->second].type.isValue() &&
( commandData.returnType == "void" ) )
{
// size is given by value and the vectors are const pointers, that is input parameters; function returns
// void
appendCommandTwoVectorsVoid( str, name, commandData, vectorParamIndices, definition );
appendedFunction = true;
} }
} }
} }
} }
break; else
{
switch ( vectorParamIndices.size() )
{
case 1: case 1:
{ {
// just one vector parameter // just one vector parameter
@ -1295,7 +1297,8 @@ void VulkanHppGenerator::appendCommand( std::string & str,
auto firstVectorParam = vectorParamIndices.begin(); auto firstVectorParam = vectorParamIndices.begin();
auto secondVectorParam = std::next( firstVectorParam ); auto secondVectorParam = std::next( firstVectorParam );
std::vector<ParamData> const & params = commandData.params; std::vector<ParamData> const & params = commandData.params;
if ( ( firstVectorParam->second != INVALID_INDEX ) && ( firstVectorParam->second == secondVectorParam->second ) ) if ( ( firstVectorParam->second != INVALID_INDEX ) &&
( firstVectorParam->second == secondVectorParam->second ) )
{ {
// the two vectors use the very same size parameter // the two vectors use the very same size parameter
if ( params[firstVectorParam->first].type.isNonConstPointer() && if ( params[firstVectorParam->first].type.isNonConstPointer() &&
@ -1306,19 +1309,12 @@ void VulkanHppGenerator::appendCommand( std::string & str,
appendCommandEnumerateTwoVectors( str, name, commandData, vectorParamIndices, definition ); appendCommandEnumerateTwoVectors( str, name, commandData, vectorParamIndices, definition );
appendedFunction = true; appendedFunction = true;
} }
else if ( params[firstVectorParam->first].type.isConstPointer() &&
params[secondVectorParam->first].type.isConstPointer() &&
params[firstVectorParam->second].type.isValue() && ( commandData.returnType == "void" ) )
{
// size is given by value and the vectors are const pointers, that is input parameters; function returns void
appendCommandTwoVectorsVoid( str, name, commandData, vectorParamIndices, definition );
appendedFunction = true;
}
} }
} }
break; break;
default: break; default: break;
} }
}
if ( appendedFunction ) if ( appendedFunction )
{ {
@ -1684,7 +1680,8 @@ ${leave})";
void VulkanHppGenerator::appendCommandSimpleVoid( std::string & str, void VulkanHppGenerator::appendCommandSimpleVoid( std::string & str,
std::string const & name, std::string const & name,
CommandData const & commandData, CommandData const & commandData,
bool definition ) const bool definition,
std::map<size_t, size_t> const & vectorParamIndices ) const
{ {
const std::string functionTemplate = R"( const std::string functionTemplate = R"(
${enter}${commandStandard}${newlineOnDefinition} ${enter}${commandStandard}${newlineOnDefinition}
@ -1696,9 +1693,10 @@ ${leave})";
std::string enter, leave; std::string enter, leave;
std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions ); std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions );
str += replaceWithMap( functionTemplate, str += replaceWithMap(
functionTemplate,
std::map<std::string, std::string>( std::map<std::string, std::string>(
{ { "commandEnhanced", constructCommandSimpleVoid( name, commandData, definition ) }, { { "commandEnhanced", constructCommandSimpleVoid( name, commandData, definition, vectorParamIndices ) },
{ "commandStandard", constructCommandStandardVoid( name, commandData, definition ) }, { "commandStandard", constructCommandStandardVoid( name, commandData, definition ) },
{ "enter", enter }, { "enter", enter },
{ "leave", leave }, { "leave", leave },
@ -2301,25 +2299,6 @@ void VulkanHppGenerator::appendEnumToString( std::string &
str += " }\n"; str += " }\n";
} }
bool needsMultiVectorSizeCheck( size_t returnParamIndex, std::map<size_t, size_t> const & vectorParamIndices )
{
for ( std::map<size_t, size_t>::const_iterator it0 = vectorParamIndices.begin(); it0 != vectorParamIndices.end();
++it0 )
{
if ( it0->first != returnParamIndex )
{
for ( std::map<size_t, size_t>::const_iterator it1 = std::next( it0 ); it1 != vectorParamIndices.end(); ++it1 )
{
if ( ( it1->first != returnParamIndex ) && ( it0->second == it1->second ) )
{
return true;
}
}
}
}
return false;
}
void VulkanHppGenerator::appendFunction( std::string & str, void VulkanHppGenerator::appendFunction( std::string & str,
std::string const & indentation, std::string const & indentation,
std::string const & name, std::string const & name,
@ -2401,9 +2380,7 @@ void VulkanHppGenerator::appendFunction( std::string & str,
// Any function that originally does not return VkResult can be marked noexcept, // Any function that originally does not return VkResult can be marked noexcept,
// if it is enhanced it must not include anything with an Allocator or needs size checks on multiple vectors // if it is enhanced it must not include anything with an Allocator or needs size checks on multiple vectors
bool hasAllocator = enhancedReturnType.find( "Allocator" ) != std::string::npos; bool hasAllocator = enhancedReturnType.find( "Allocator" ) != std::string::npos;
if ( !enhanced || if ( !enhanced || ( commandData.returnType != "VkResult" && !( enhanced && hasAllocator ) ) )
( commandData.returnType != "VkResult" &&
!( enhanced && ( hasAllocator || needsMultiVectorSizeCheck( returnParamIndex, vectorParamIndices ) ) ) ) )
{ {
str += " VULKAN_HPP_NOEXCEPT"; str += " VULKAN_HPP_NOEXCEPT";
} }
@ -3726,19 +3703,33 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector<Param
{ {
if ( skippedParams.find( i ) == skippedParams.end() ) if ( skippedParams.find( i ) == skippedParams.end() )
{ {
if ( beginsWith( params[i].type.type, "Vk" ) ) if ( params[i].type.isConstPointer() && !params[i].len.empty() )
{ {
if ( params[i].type.isConstPointer() ) if ( params[i].len == "null-terminated" )
{ {
if ( !params[i].len.empty() ) assert( params[i].type.type == "char" );
argumentList += "const std::string & ";
}
else
{ {
std::string type = params[i].type.compose(); std::string type = params[i].type.compose();
assert( endsWith( type, "*" ) ); assert( endsWith( type, "*" ) );
type.pop_back(); type.pop_back();
size_t pos = type.find( "void" );
argumentList += "ArrayProxy<" + type + "> const & " + startLowerCase( stripPrefix( params[i].name, "p" ) ); if ( pos != std::string::npos )
{
type.replace( pos, 4, "T" );
} }
else if ( params[i].optional )
argumentList += "ArrayProxy<" + type + "> const & ";
}
argumentList += startLowerCase( stripPrefix( params[i].name, "p" ) );
}
else if ( beginsWith( params[i].type.type, "Vk" ) )
{
if ( params[i].type.isConstPointer() )
{
if ( params[i].optional )
{ {
assert( params[i].type.isConstPointer() ); assert( params[i].type.isConstPointer() );
argumentList += "Optional<const " + stripPrefix( params[i].type.type, "Vk" ) + "> " + argumentList += "Optional<const " + stripPrefix( params[i].type.type, "Vk" ) + "> " +
@ -3903,22 +3894,47 @@ std::string
VulkanHppGenerator::constructCallArgumentsVectors( std::vector<ParamData> const & params, VulkanHppGenerator::constructCallArgumentsVectors( std::vector<ParamData> const & params,
std::map<size_t, size_t> const & vectorParamIndices ) const std::map<size_t, size_t> const & vectorParamIndices ) const
{ {
assert( !vectorParamIndices.empty() ); std::map<size_t, size_t> vectorSizeIndices;
size_t countIndex = vectorParamIndices.begin()->second; for ( auto const & vpi : vectorParamIndices )
{
if ( vectorSizeIndices.find( vpi.second ) == vectorSizeIndices.end() )
{
vectorSizeIndices[vpi.second] = vpi.first;
}
}
std::string arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) ); std::string arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) );
for ( size_t i = 1; i < params.size(); i++ ) for ( size_t i = 1; i < params.size(); i++ )
{ {
arguments += ", "; arguments += ", ";
if ( i == countIndex ) auto vsi = vectorSizeIndices.find( i );
if ( vsi != vectorSizeIndices.end() )
{ {
arguments += startLowerCase( stripPrefix( params[vectorParamIndices.begin()->first].name, "p" ) ) + ".size()"; assert( params[i].type.isValue() );
arguments += startLowerCase( stripPrefix( params[vsi->second].name, "p" ) ) + ".size()";
if ( params[vsi->second].type.type == "void" )
{
arguments += " * sizeof( T )";
}
} }
else if ( vectorParamIndices.find( i ) != vectorParamIndices.end() ) else if ( vectorParamIndices.find( i ) != vectorParamIndices.end() )
{ {
assert( !params[i].type.prefix.empty() && !params[i].type.postfix.empty() ); assert( !params[i].type.isValue() );
std::string argName = startLowerCase( stripPrefix( params[i].name, "p" ) );
if ( beginsWith( params[i].type.type, "Vk" ) || ( params[i].type.type == "void" ) )
{
arguments += "reinterpret_cast<" + params[i].type.prefix + " " + params[i].type.type + " " + arguments += "reinterpret_cast<" + params[i].type.prefix + " " + params[i].type.type + " " +
params[i].type.postfix + ">( " + startLowerCase( stripPrefix( params[i].name, "p" ) ) + ".data() )"; params[i].type.postfix + ">( " + argName + ".data()" + " )";
}
else if ( params[i].type.type == "char" )
{
assert( params[i].len == "null-terminated" );
arguments += argName + ".c_str()";
}
else
{
arguments += argName + ".data()";
}
} }
else else
{ {
@ -4345,39 +4361,57 @@ std::string VulkanHppGenerator::constructCommandSimple( std::string const & name
std::string VulkanHppGenerator::constructCommandSimpleVoid( std::string const & name, std::string VulkanHppGenerator::constructCommandSimpleVoid( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
bool definition ) const bool definition,
std::map<size_t, size_t> const & vectorParamIndices ) const
{ {
std::string str; std::string str;
std::string argumentList = constructArgumentListEnhanced( commandData.params, { 0 }, definition, false ); std::set<size_t> skippedParameters = { 0 };
for ( auto const & vpi : vectorParamIndices )
{
if ( vpi.second != INVALID_INDEX )
{
skippedParameters.insert( vpi.second );
}
}
std::string argumentList = constructArgumentListEnhanced( commandData.params, skippedParameters, definition, false );
std::string commandName = determineCommandName( name, commandData.params[0].type.type ); std::string commandName = determineCommandName( name, commandData.params[0].type.type );
std::string typenameT = ( ( vectorParamIndices.size() == 1 ) &&
( commandData.params[vectorParamIndices.begin()->first].type.type == "void" ) )
? "typename T, "
: "";
if ( definition ) if ( definition )
{ {
std::string const functionTemplate = std::string const functionTemplate =
R"( template <typename Dispatch> R"( template <${typenameT}typename Dispatch>
VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
{ {${vectorSizeCheck}
d.${vkCommand}( ${callArguments} ); d.${vkCommand}( ${callArguments} );
})"; })";
str = replaceWithMap( str =
functionTemplate, replaceWithMap( functionTemplate,
std::map<std::string, std::string>( { { "argumentList", argumentList }, std::map<std::string, std::string>(
{ "callArguments", constructCallArguments( commandData.params, true ) }, { { "argumentList", argumentList },
{ "callArguments", constructCallArgumentsVectors( commandData.params, vectorParamIndices ) },
{ "className", stripPrefix( commandData.handle, "Vk" ) }, { "className", stripPrefix( commandData.handle, "Vk" ) },
{ "commandName", commandName }, { "commandName", commandName },
{ "typenameT", typenameT },
{ "vectorSizeCheck", constructVectorSizeCheck( name, commandData, vectorParamIndices ) },
{ "vkCommand", name } } ) ); { "vkCommand", name } } ) );
} }
else else
{ {
std::string const functionTemplate = std::string const functionTemplate =
R"( template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> R"( template <${typenameT}typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;)"; void ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;)";
str = replaceWithMap( str = replaceWithMap(
functionTemplate, functionTemplate,
std::map<std::string, std::string>( { { "argumentList", argumentList }, { "commandName", commandName } } ) ); std::map<std::string, std::string>(
{ { "argumentList", argumentList }, { "commandName", commandName }, { "typenameT", typenameT } } ) );
} }
return str; return str;
@ -4392,16 +4426,14 @@ std::string VulkanHppGenerator::constructCommandStandard( std::string const & na
std::string argumentList = constructArgumentListStandard( commandData.params, { 0 } ); std::string argumentList = constructArgumentListStandard( commandData.params, { 0 } );
std::string commandName = determineCommandName( name, commandData.params[0].type.type ); std::string commandName = determineCommandName( name, commandData.params[0].type.type );
std::string nodiscard = constructNoDiscardStandard( commandData ); std::string nodiscard = constructNoDiscardStandard( commandData );
assert( ( commandData.returnType == "void" ) || ( commandData.returnType == "VkResult" ) ); std::string returnType = stripPrefix( commandData.returnType, "Vk" );
std::string returnType = ( commandData.returnType == "void" ) ? "void" : "Result";
if ( definition ) if ( definition )
{ {
std::string functionBody = "d." + name + "( " + constructCallArguments( commandData.params, false ) + " )"; std::string functionBody = "d." + name + "( " + constructCallArguments( commandData.params, false ) + " )";
if ( returnType != "void" ) if ( returnType != "void" )
{ {
assert( returnType == "Result" ); functionBody = "return static_cast<" + returnType + ">( " + functionBody + " )";
functionBody = "return static_cast<Result>( " + functionBody + " )";
} }
std::string const functionTemplate = std::string const functionTemplate =
@ -4816,6 +4848,74 @@ std::string VulkanHppGenerator::constructSuccessCodeList( std::vector<std::strin
return successCodeList; return successCodeList;
} }
std::string VulkanHppGenerator::constructVectorSizeCheck( std::string const & name,
CommandData const & commandData,
std::map<size_t, size_t> const & vectorParamIndices ) const
{
std::string str;
std::map<size_t, std::vector<size_t>> countToVectorMap;
for ( auto const & vpi : vectorParamIndices )
{
if ( vpi.second != INVALID_INDEX )
{
countToVectorMap[vpi.second].push_back( vpi.first );
}
}
// check if there's at least one count used multiple times
if ( std::find_if( countToVectorMap.begin(), countToVectorMap.end(), []( auto const & cvm ) {
return 1 < cvm.second.size();
} ) != countToVectorMap.end() )
{
std::string const assertTemplate =
" VULKAN_HPP_ASSERT( ${firstVectorName}.size() == ${secondVectorName}.size() );";
std::string const throwTemplate =
R"#( if ( ${firstVectorName}.size() != ${secondVectorName}.size() )
{
throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::${className}::${commandName}: ${firstVectorName}.size() != ${secondVectorName}.size()" );
})#";
std::string commandName = determineCommandName( name, commandData.params[0].type.type );
std::string assertions, throws;
for ( auto const & cvm : countToVectorMap )
{
for ( size_t i = 1; i < cvm.second.size(); i++ )
{
assertions += replaceWithMap(
assertTemplate,
{ { "firstVectorName", startLowerCase( stripPrefix( commandData.params[cvm.second[0]].name, "p" ) ) },
{ "secondVectorName", startLowerCase( stripPrefix( commandData.params[cvm.second[i]].name, "p" ) ) } } );
throws += replaceWithMap(
throwTemplate,
{ { "firstVectorName", startLowerCase( stripPrefix( commandData.params[cvm.second[0]].name, "p" ) ) },
{ "secondVectorName", startLowerCase( stripPrefix( commandData.params[cvm.second[i]].name, "p" ) ) },
{ "className", stripPrefix( commandData.handle, "Vk" ) },
{ "commandName", commandName } } );
if ( i + 1 < cvm.second.size() )
{
assertions += "\n";
throws += "\n";
}
}
}
std::string const sizeCheckTemplate =
R"#(
#ifdef VULKAN_HPP_NO_EXCEPTIONS
${assertions}
#else
${throws}
#endif /*VULKAN_HPP_NO_EXCEPTIONS*/
)#";
str = replaceWithMap( sizeCheckTemplate, { { "assertions", assertions }, { "throws", throws } } );
}
return str;
}
template <class InputIt, class UnaryPredicate> template <class InputIt, class UnaryPredicate>
std::vector<InputIt> findAll( InputIt first, InputIt last, UnaryPredicate p ) std::vector<InputIt> findAll( InputIt first, InputIt last, UnaryPredicate p )
{ {

11
VulkanHppGenerator.hpp
View File

@ -333,7 +333,8 @@ private:
void appendCommandSimpleVoid( std::string & str, void appendCommandSimpleVoid( std::string & str,
std::string const & name, std::string const & name,
CommandData const & commandData, CommandData const & commandData,
bool definition ) const; bool definition,
std::map<size_t, size_t> const & vectorParamIndices ) const;
void appendCommandTrivialVoid( std::string & str, void appendCommandTrivialVoid( std::string & str,
std::string const & name, std::string const & name,
CommandData const & commandData, CommandData const & commandData,
@ -562,8 +563,10 @@ private:
bool definition ) const; bool definition ) const;
std::string std::string
constructCommandSimple( std::string const & name, CommandData const & commandData, bool definition ) const; constructCommandSimple( std::string const & name, CommandData const & commandData, bool definition ) const;
std::string std::string constructCommandSimpleVoid( std::string const & name,
constructCommandSimpleVoid( std::string const & name, CommandData const & commandData, bool definition ) const; CommandData const & commandData,
bool definition,
std::map<size_t, size_t> const & vectorParamIndices ) const;
std::string std::string
constructCommandStandard( std::string const & name, CommandData const & commandData, bool definition ) const; constructCommandStandard( std::string const & name, CommandData const & commandData, bool definition ) const;
std::string std::string
@ -608,6 +611,8 @@ private:
std::string constructNoDiscardStandard( CommandData const & commandData ) const; std::string constructNoDiscardStandard( CommandData const & commandData ) const;
std::string constructReturnType( CommandData const & commandData, std::string const & baseType ) const; std::string constructReturnType( CommandData const & commandData, std::string const & baseType ) const;
std::string constructSuccessCodeList( std::vector<std::string> const & successCodes ) const; std::string constructSuccessCodeList( std::vector<std::string> const & successCodes ) const;
std::string constructVectorSizeCheck( std::string const & name, CommandData const & commandData,
std::map<size_t, size_t> const & vectorParamIndices ) const;
void checkCorrectness(); void checkCorrectness();
bool containsArray( std::string const & type ) const; bool containsArray( std::string const & type ) const;
bool containsUnion( std::string const & type ) const; bool containsUnion( std::string const & type ) const;

237
vulkan/vulkan.hpp
View File

@ -37933,7 +37933,8 @@ namespace VULKAN_HPP_NAMESPACE
void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, void beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#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>
@ -37993,7 +37994,8 @@ namespace VULKAN_HPP_NAMESPACE
ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#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>
@ -38007,7 +38009,7 @@ namespace VULKAN_HPP_NAMESPACE
void bindVertexBuffers( uint32_t firstBinding, void bindVertexBuffers( uint32_t firstBinding,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#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>
@ -38025,7 +38027,7 @@ namespace VULKAN_HPP_NAMESPACE
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#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>
@ -38088,7 +38090,7 @@ namespace VULKAN_HPP_NAMESPACE
void buildAccelerationStructureKHR( void buildAccelerationStructureKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildOffsetInfoKHR * const> const & pOffsetInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildOffsetInfoKHR * const> const & pOffsetInfos,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VK_ENABLE_BETA_EXTENSIONS*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/
@ -38537,10 +38539,11 @@ namespace VULKAN_HPP_NAMESPACE
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 Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endTransformFeedbackEXT( uint32_t firstCounterBuffer, void
endTransformFeedbackEXT( uint32_t firstCounterBuffer,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#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>
@ -38675,7 +38678,6 @@ namespace VULKAN_HPP_NAMESPACE
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*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
VULKAN_HPP_NAMESPACE::PipelineLayout layout, VULKAN_HPP_NAMESPACE::PipelineLayout layout,
@ -38683,15 +38685,6 @@ 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;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
VULKAN_HPP_NAMESPACE::PipelineLayout layout,
uint32_t set,
const void * pData,
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 resetEvent( VULKAN_HPP_NAMESPACE::Event event, void resetEvent( VULKAN_HPP_NAMESPACE::Event event,
@ -38735,15 +38728,9 @@ namespace VULKAN_HPP_NAMESPACE
void setBlendConstants( const float blendConstants[4], void setBlendConstants( const float blendConstants[4],
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
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;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setCheckpointNV( const void * pCheckpointMarker,
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 void
@ -55446,7 +55433,7 @@ namespace VULKAN_HPP_NAMESPACE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains, void setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains,
ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata, ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#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>
@ -55511,37 +55498,19 @@ namespace VULKAN_HPP_NAMESPACE
void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
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;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
const void * pData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
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;
#else
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
const void * pData,
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 updateDescriptorSets( uint32_t descriptorWriteCount, void updateDescriptorSets( uint32_t descriptorWriteCount,
@ -88666,7 +88635,7 @@ namespace VULKAN_HPP_NAMESPACE
int32_t messageCode, int32_t messageCode,
const std::string & layerPrefix, const std::string & layerPrefix,
const std::string & message, const std::string & message,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#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>
@ -89328,7 +89297,7 @@ namespace VULKAN_HPP_NAMESPACE
uint32_t firstCounterBuffer, uint32_t firstCounterBuffer,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets,
Dispatch const & d ) const Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
# ifdef VULKAN_HPP_NO_EXCEPTIONS # ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() ); VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() );
@ -89340,6 +89309,7 @@ namespace VULKAN_HPP_NAMESPACE
"::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
} }
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer,
firstCounterBuffer, firstCounterBuffer,
counterBuffers.size(), counterBuffers.size(),
@ -89367,6 +89337,7 @@ namespace VULKAN_HPP_NAMESPACE
dynamicOffsetCount, dynamicOffsetCount,
pDynamicOffsets ); pDynamicOffsets );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -89447,6 +89418,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkDeviceSize *>( pOffsets ), reinterpret_cast<const VkDeviceSize *>( pOffsets ),
reinterpret_cast<const VkDeviceSize *>( pSizes ) ); reinterpret_cast<const VkDeviceSize *>( pSizes ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -89454,35 +89426,24 @@ namespace VULKAN_HPP_NAMESPACE
ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,
Dispatch const & d ) const Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
# ifdef VULKAN_HPP_NO_EXCEPTIONS # ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
VULKAN_HPP_ASSERT( buffers.size() == sizes.size() );
# else # else
if ( buffers.size() != offsets.size() ) if ( buffers.size() != offsets.size() )
{ {
throw LogicError( VULKAN_HPP_NAMESPACE_STRING throw LogicError( VULKAN_HPP_NAMESPACE_STRING
"::VkCommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" ); "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" );
} }
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/
# ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( buffers.size() == sizes.size() );
# else
if ( buffers.size() != sizes.size() ) if ( buffers.size() != sizes.size() )
{ {
throw LogicError( VULKAN_HPP_NAMESPACE_STRING throw LogicError( VULKAN_HPP_NAMESPACE_STRING
"::VkCommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" ); "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" );
}
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/
# ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( offsets.size() == sizes.size() );
# else
if ( offsets.size() != sizes.size() )
{
throw LogicError( VULKAN_HPP_NAMESPACE_STRING
"::VkCommandBuffer::bindTransformFeedbackBuffersEXT: offsets.size() != sizes.size()" );
} }
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer,
firstBinding, firstBinding,
buffers.size(), buffers.size(),
@ -89512,7 +89473,7 @@ namespace VULKAN_HPP_NAMESPACE
CommandBuffer::bindVertexBuffers( uint32_t firstBinding, CommandBuffer::bindVertexBuffers( uint32_t firstBinding,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
Dispatch const & d ) const Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
# ifdef VULKAN_HPP_NO_EXCEPTIONS # ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
@ -89523,6 +89484,7 @@ namespace VULKAN_HPP_NAMESPACE
"::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
} }
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
d.vkCmdBindVertexBuffers( m_commandBuffer, d.vkCmdBindVertexBuffers( m_commandBuffer,
firstBinding, firstBinding,
buffers.size(), buffers.size(),
@ -89548,6 +89510,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkDeviceSize *>( pSizes ), reinterpret_cast<const VkDeviceSize *>( pSizes ),
reinterpret_cast<const VkDeviceSize *>( pStrides ) ); reinterpret_cast<const VkDeviceSize *>( pStrides ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -89556,62 +89519,30 @@ namespace VULKAN_HPP_NAMESPACE
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides,
Dispatch const & d ) const Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
# ifdef VULKAN_HPP_NO_EXCEPTIONS # ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
VULKAN_HPP_ASSERT( buffers.size() == sizes.size() );
VULKAN_HPP_ASSERT( buffers.size() == strides.size() );
# else # else
if ( buffers.size() != offsets.size() ) if ( buffers.size() != offsets.size() )
{ {
throw LogicError( VULKAN_HPP_NAMESPACE_STRING throw LogicError( VULKAN_HPP_NAMESPACE_STRING
"::VkCommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" ); "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" );
} }
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/
# ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( buffers.size() == sizes.size() );
# else
if ( buffers.size() != sizes.size() ) if ( buffers.size() != sizes.size() )
{ {
throw LogicError( VULKAN_HPP_NAMESPACE_STRING throw LogicError( VULKAN_HPP_NAMESPACE_STRING
"::VkCommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" ); "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" );
} }
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/
# ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( buffers.size() == strides.size() );
# else
if ( buffers.size() != strides.size() ) if ( buffers.size() != strides.size() )
{ {
throw LogicError( VULKAN_HPP_NAMESPACE_STRING throw LogicError( VULKAN_HPP_NAMESPACE_STRING
"::VkCommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" ); "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" );
}
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/
# ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( offsets.size() == sizes.size() );
# else
if ( offsets.size() != sizes.size() )
{
throw LogicError( VULKAN_HPP_NAMESPACE_STRING
"::VkCommandBuffer::bindVertexBuffers2EXT: offsets.size() != sizes.size()" );
}
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/
# ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( offsets.size() == strides.size() );
# else
if ( offsets.size() != strides.size() )
{
throw LogicError( VULKAN_HPP_NAMESPACE_STRING
"::VkCommandBuffer::bindVertexBuffers2EXT: offsets.size() != strides.size()" );
}
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/
# ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( sizes.size() == strides.size() );
# else
if ( sizes.size() != strides.size() )
{
throw LogicError( VULKAN_HPP_NAMESPACE_STRING
"::VkCommandBuffer::bindVertexBuffers2EXT: sizes.size() != strides.size()" );
} }
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
d.vkCmdBindVertexBuffers2EXT( m_commandBuffer, d.vkCmdBindVertexBuffers2EXT( m_commandBuffer,
firstBinding, firstBinding,
buffers.size(), buffers.size(),
@ -89641,6 +89572,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkImageBlit *>( pRegions ), reinterpret_cast<const VkImageBlit *>( pRegions ),
static_cast<VkFilter>( filter ) ); static_cast<VkFilter>( filter ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image srcImage,
@ -89734,7 +89666,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureKHR( VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureKHR(
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildOffsetInfoKHR * const> const & pOffsetInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildOffsetInfoKHR * const> const & pOffsetInfos,
Dispatch const & d ) const Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
# ifdef VULKAN_HPP_NO_EXCEPTIONS # ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( infos.size() == pOffsetInfos.size() ); VULKAN_HPP_ASSERT( infos.size() == pOffsetInfos.size() );
@ -89745,6 +89677,7 @@ namespace VULKAN_HPP_NAMESPACE
"::CommandBuffer::buildAccelerationStructureKHR: infos.size() != pOffsetInfos.size()" ); "::CommandBuffer::buildAccelerationStructureKHR: infos.size() != pOffsetInfos.size()" );
} }
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
d.vkCmdBuildAccelerationStructureKHR( d.vkCmdBuildAccelerationStructureKHR(
m_commandBuffer, m_commandBuffer,
infos.size(), infos.size(),
@ -89815,6 +89748,7 @@ namespace VULKAN_HPP_NAMESPACE
rectCount, rectCount,
reinterpret_cast<const VkClearRect *>( pRects ) ); reinterpret_cast<const VkClearRect *>( pRects ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -89845,6 +89779,7 @@ namespace VULKAN_HPP_NAMESPACE
rangeCount, rangeCount,
reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) ); reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -89879,6 +89814,7 @@ namespace VULKAN_HPP_NAMESPACE
rangeCount, rangeCount,
reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) ); reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -89966,6 +89902,7 @@ namespace VULKAN_HPP_NAMESPACE
regionCount, regionCount,
reinterpret_cast<const VkBufferCopy *>( pRegions ) ); reinterpret_cast<const VkBufferCopy *>( pRegions ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
@ -90013,6 +89950,7 @@ namespace VULKAN_HPP_NAMESPACE
regionCount, regionCount,
reinterpret_cast<const VkBufferImageCopy *>( pRegions ) ); reinterpret_cast<const VkBufferImageCopy *>( pRegions ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -90067,6 +90005,7 @@ namespace VULKAN_HPP_NAMESPACE
regionCount, regionCount,
reinterpret_cast<const VkImageCopy *>( pRegions ) ); reinterpret_cast<const VkImageCopy *>( pRegions ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, VULKAN_HPP_INLINE void CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image srcImage,
@ -90117,6 +90056,7 @@ namespace VULKAN_HPP_NAMESPACE
regionCount, regionCount,
reinterpret_cast<const VkBufferImageCopy *>( pRegions ) ); reinterpret_cast<const VkBufferImageCopy *>( pRegions ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -90573,7 +90513,7 @@ namespace VULKAN_HPP_NAMESPACE
uint32_t firstCounterBuffer, uint32_t firstCounterBuffer,
ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets, ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets,
Dispatch const & d ) const Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
# ifdef VULKAN_HPP_NO_EXCEPTIONS # ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() ); VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() );
@ -90585,6 +90525,7 @@ namespace VULKAN_HPP_NAMESPACE
"::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
} }
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, d.vkCmdEndTransformFeedbackEXT( m_commandBuffer,
firstCounterBuffer, firstCounterBuffer,
counterBuffers.size(), counterBuffers.size(),
@ -90601,6 +90542,7 @@ namespace VULKAN_HPP_NAMESPACE
d.vkCmdExecuteCommands( d.vkCmdExecuteCommands(
m_commandBuffer, commandBufferCount, reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) ); m_commandBuffer, commandBufferCount, reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -90743,6 +90685,7 @@ namespace VULKAN_HPP_NAMESPACE
imageMemoryBarrierCount, imageMemoryBarrierCount,
reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) ); reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier(
@ -90802,6 +90745,7 @@ namespace VULKAN_HPP_NAMESPACE
size, size,
pValues ); pValues );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename T, typename Dispatch> template <typename T, typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout,
@ -90835,6 +90779,7 @@ namespace VULKAN_HPP_NAMESPACE
descriptorWriteCount, descriptorWriteCount,
reinterpret_cast<const VkWriteDescriptorSet *>( pDescriptorWrites ) ); reinterpret_cast<const VkWriteDescriptorSet *>( pDescriptorWrites ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR(
@ -90853,7 +90798,6 @@ namespace VULKAN_HPP_NAMESPACE
} }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR(
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
@ -90868,22 +90812,6 @@ namespace VULKAN_HPP_NAMESPACE
set, set,
pData ); pData );
} }
#else
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR(
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
VULKAN_HPP_NAMESPACE::PipelineLayout layout,
uint32_t set,
const void * pData,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer,
static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
static_cast<VkPipelineLayout>( layout ),
set,
pData );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event event, VULKAN_HPP_INLINE void CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event event,
@ -90919,6 +90847,7 @@ namespace VULKAN_HPP_NAMESPACE
regionCount, regionCount,
reinterpret_cast<const VkImageResolve *>( pRegions ) ); reinterpret_cast<const VkImageResolve *>( pRegions ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -90963,21 +90892,12 @@ namespace VULKAN_HPP_NAMESPACE
d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants ); d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants );
} }
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void * pCheckpointMarker, VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void * pCheckpointMarker,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker ); d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker );
} }
#else
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void * pCheckpointMarker,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -90991,6 +90911,7 @@ namespace VULKAN_HPP_NAMESPACE
customSampleOrderCount, customSampleOrderCount,
reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( pCustomSampleOrders ) ); reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( pCustomSampleOrders ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV(
@ -91082,6 +91003,7 @@ namespace VULKAN_HPP_NAMESPACE
discardRectangleCount, discardRectangleCount,
reinterpret_cast<const VkRect2D *>( pDiscardRectangles ) ); reinterpret_cast<const VkRect2D *>( pDiscardRectangles ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -91115,6 +91037,7 @@ namespace VULKAN_HPP_NAMESPACE
exclusiveScissorCount, exclusiveScissorCount,
reinterpret_cast<const VkRect2D *>( pExclusiveScissors ) ); reinterpret_cast<const VkRect2D *>( pExclusiveScissors ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -91246,6 +91169,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) ); d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor,
@ -91264,6 +91188,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
d.vkCmdSetScissorWithCountEXT( m_commandBuffer, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) ); d.vkCmdSetScissorWithCountEXT( m_commandBuffer, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -91331,6 +91256,7 @@ namespace VULKAN_HPP_NAMESPACE
d.vkCmdSetViewport( d.vkCmdSetViewport(
m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) ); m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport,
@ -91354,6 +91280,7 @@ namespace VULKAN_HPP_NAMESPACE
viewportCount, viewportCount,
reinterpret_cast<const VkShadingRatePaletteNV *>( pShadingRatePalettes ) ); reinterpret_cast<const VkShadingRatePaletteNV *>( pShadingRatePalettes ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV(
@ -91381,6 +91308,7 @@ namespace VULKAN_HPP_NAMESPACE
viewportCount, viewportCount,
reinterpret_cast<const VkViewportWScalingNV *>( pViewportWScalings ) ); reinterpret_cast<const VkViewportWScalingNV *>( pViewportWScalings ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV(
@ -91403,6 +91331,7 @@ namespace VULKAN_HPP_NAMESPACE
d.vkCmdSetViewportWithCountEXT( d.vkCmdSetViewportWithCountEXT(
m_commandBuffer, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) ); m_commandBuffer, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -91547,6 +91476,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkDeviceSize>( dataSize ), static_cast<VkDeviceSize>( dataSize ),
pData ); pData );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename T, typename Dispatch> template <typename T, typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
@ -91588,6 +91518,7 @@ namespace VULKAN_HPP_NAMESPACE
imageMemoryBarrierCount, imageMemoryBarrierCount,
reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) ); reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -91631,6 +91562,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkQueryPool>( queryPool ), static_cast<VkQueryPool>( queryPool ),
firstQuery ); firstQuery );
} }
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR( VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR(
@ -91668,6 +91600,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkQueryPool>( queryPool ), static_cast<VkQueryPool>( queryPool ),
firstQuery ); firstQuery );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV(
@ -96245,6 +96178,7 @@ namespace VULKAN_HPP_NAMESPACE
commandBufferCount, commandBufferCount,
reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) ); reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -96270,6 +96204,7 @@ namespace VULKAN_HPP_NAMESPACE
commandBufferCount, commandBufferCount,
reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) ); reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::CommandPool commandPool, VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
@ -99623,7 +99558,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
Device::setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains, Device::setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains,
ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata, ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,
Dispatch const & d ) const Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
# ifdef VULKAN_HPP_NO_EXCEPTIONS # ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() ); VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() );
@ -99634,6 +99569,7 @@ namespace VULKAN_HPP_NAMESPACE
"::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" );
} }
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
d.vkSetHdrMetadataEXT( m_device, d.vkSetHdrMetadataEXT( m_device,
swapchains.size(), swapchains.size(),
reinterpret_cast<const VkSwapchainKHR *>( swapchains.data() ), reinterpret_cast<const VkSwapchainKHR *>( swapchains.data() ),
@ -99751,7 +99687,6 @@ namespace VULKAN_HPP_NAMESPACE
d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) ); d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
} }
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
Device::updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, Device::updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
@ -99764,22 +99699,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
pData ); pData );
} }
#else
template <typename Dispatch>
VULKAN_HPP_INLINE void
Device::updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
const void * pData,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
d.vkUpdateDescriptorSetWithTemplate( m_device,
static_cast<VkDescriptorSet>( descriptorSet ),
static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
pData );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
@ -99792,20 +99712,6 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
pData ); pData );
} }
#else
template <typename Dispatch>
VULKAN_HPP_INLINE void
Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
const void * pData,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
d.vkUpdateDescriptorSetWithTemplateKHR( m_device,
static_cast<VkDescriptorSet>( descriptorSet ),
static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
pData );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -99821,6 +99727,7 @@ namespace VULKAN_HPP_NAMESPACE
descriptorCopyCount, descriptorCopyCount,
reinterpret_cast<const VkCopyDescriptorSet *>( pDescriptorCopies ) ); reinterpret_cast<const VkCopyDescriptorSet *>( pDescriptorCopies ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_INLINE void
@ -100810,6 +100717,7 @@ namespace VULKAN_HPP_NAMESPACE
pLayerPrefix, pLayerPrefix,
pMessage ); pMessage );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags,
@ -100819,17 +100727,8 @@ namespace VULKAN_HPP_NAMESPACE
int32_t messageCode, int32_t messageCode,
const std::string & layerPrefix, const std::string & layerPrefix,
const std::string & message, const std::string & message,
Dispatch const & d ) const Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
# ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( layerPrefix.size() == message.size() );
# else
if ( layerPrefix.size() != message.size() )
{
throw LogicError( VULKAN_HPP_NAMESPACE_STRING
"::VkInstance::debugReportMessageEXT: layerPrefix.size() != message.size()" );
}
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/
d.vkDebugReportMessageEXT( m_instance, d.vkDebugReportMessageEXT( m_instance,
static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportFlagsEXT>( flags ),
static_cast<VkDebugReportObjectTypeEXT>( objectType ), static_cast<VkDebugReportObjectTypeEXT>( objectType ),