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

Refactor function generation of void-functions enumerating a single vector of data.

Browse Source
This commit is contained in:
asuessenbach 2020-09-28 16:34:50 +02:00
parent d8c299104b
commit b6e6294fb9
3 changed files with 488 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

246
VulkanHppGenerator.cpp
View File

@ -1224,7 +1224,7 @@ void VulkanHppGenerator::appendCommand( std::string & str,
bool definition ) const bool definition ) const
{ {
bool appendedFunction = false; bool appendedFunction = false;
std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices( commandData.params ); std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndicesNew( commandData.params );
std::vector<size_t> nonConstPointerParamIndices = determineNonConstPointerParamIndices( commandData.params ); std::vector<size_t> nonConstPointerParamIndices = determineNonConstPointerParamIndices( commandData.params );
if ( nonConstPointerParamIndices.empty() ) if ( nonConstPointerParamIndices.empty() )
{ {
@ -1288,14 +1288,24 @@ void VulkanHppGenerator::appendCommand( std::string & str,
{ {
// just one vector parameter // just one vector parameter
auto vectorParamIndexIt = vectorParamIndices.begin(); auto vectorParamIndexIt = vectorParamIndices.begin();
if ( commandData.params[vectorParamIndexIt->first].type.isNonConstPointer() && if ( commandData.params[vectorParamIndexIt->second].type.isValue() )
( commandData.params[vectorParamIndexIt->first].type.type == "void" ) &&
commandData.params[vectorParamIndexIt->second].type.isValue() )
{ {
// the vector is a non-const pointer to void (that is, a return parameter), and the size is given by value // the size of the vector parameter is given by a value -> just get that stuff
assert( commandData.params[vectorParamIndexIt->first].type.isNonConstPointer() );
assert( commandData.params[vectorParamIndexIt->first].type.type == "void" );
appendCommandGetVector( str, name, commandData, vectorParamIndices, definition ); appendCommandGetVector( str, name, commandData, vectorParamIndices, definition );
appendedFunction = true; appendedFunction = true;
} }
else if ( ( commandData.returnType == "void" ) &&
!determineStructureChaining(
commandData.params[vectorParamIndexIt->first].type.type, m_extendedStructs, m_structureAliases ) )
{
// the size of the vector parameter itself is a pointer -> enumerate the values
assert( commandData.params[vectorParamIndexIt->first].type.isNonConstPointer() );
assert( commandData.params[vectorParamIndexIt->first].type.type != "void" );
appendCommandEnumerateVoid( str, name, commandData, *vectorParamIndexIt, definition );
appendedFunction = true;
}
} }
break; break;
case 2: case 2:
@ -1342,6 +1352,8 @@ void VulkanHppGenerator::appendCommand( std::string & str,
bool twoStep = isTwoStepAlgorithm( commandData.params ); bool twoStep = isTwoStepAlgorithm( commandData.params );
vectorParamIndices =
determineVectorParamIndices( commandData.params ); // determine vector param indices the old way again
size_t returnParamIndex = determineReturnParamIndex( commandData, vectorParamIndices, twoStep ); size_t returnParamIndex = determineReturnParamIndex( commandData, vectorParamIndices, twoStep );
bool isStructureChain = bool isStructureChain =
( returnParamIndex != INVALID_INDEX ) && ( returnParamIndex != INVALID_INDEX ) &&
@ -1625,6 +1637,36 @@ ${commandEnhancedWithAllocators}
{ "newlineOnDefinition", definition ? "\n" : "" } } ) ); { "newlineOnDefinition", definition ? "\n" : "" } } ) );
} }
void VulkanHppGenerator::appendCommandEnumerateVoid( std::string & str,
std::string const & name,
CommandData const & commandData,
std::pair<size_t, size_t> const & vectorParamIndex,
bool definition ) const
{
assert( commandData.returnType == "void" );
std::string enter, leave;
std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions );
assert( enter.empty() );
const std::string functionTemplate = R"(
${commandStandard}${newlineOnDefinition}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
${commandEnhanced}${newlineOnDefinition}
${commandEnhancedWithAllocators}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
)";
str += replaceWithMap(
functionTemplate,
std::map<std::string, std::string>(
{ { "commandEnhanced", constructCommandEnumerateVoid( name, commandData, vectorParamIndex, definition, false ) },
{ "commandEnhancedWithAllocators",
constructCommandEnumerateVoid( name, commandData, vectorParamIndex, definition, true ) },
{ "commandStandard", constructCommandStandard( name, commandData, definition ) },
{ "newlineOnDefinition", definition ? "\n" : "" } } ) );
}
void VulkanHppGenerator::appendCommandGetVector( std::string & str, void VulkanHppGenerator::appendCommandGetVector( std::string & str,
std::string const & name, std::string const & name,
CommandData const & commandData, CommandData const & commandData,
@ -3821,37 +3863,48 @@ std::string VulkanHppGenerator::constructArgumentListStandard( std::vector<Param
std::string VulkanHppGenerator::constructCallArgument( ParamData const & param, bool enhanced ) const std::string VulkanHppGenerator::constructCallArgument( ParamData const & param, bool enhanced ) const
{ {
std::string argument = param.name; std::string argument;
if ( beginsWith( param.type.type, "Vk" ) ) if ( enhanced && param.len == "null-terminated" )
{ {
if ( !param.arraySizes.empty() ) assert( !param.type.isValue() );
assert( param.type.type == "char" );
assert( beginsWith( param.name, "p" ) );
argument = startLowerCase( stripPrefix( param.name, "p" ) ) + ".c_str()";
}
else
{
argument = param.name;
if ( beginsWith( param.type.type, "Vk" ) )
{ {
assert( param.arraySizes.size() == 1 ); if ( !param.arraySizes.empty() )
assert( param.type.isValue() );
assert( param.type.prefix == "const" );
argument = "reinterpret_cast<const " + param.type.type + "*>( " + argument + " )";
}
else if ( param.type.isValue() )
{
argument = "static_cast<" + param.type.type + ">( " + argument + " )";
}
else
{
assert( !param.type.postfix.empty() );
if ( enhanced )
{ {
argument = startLowerCase( stripPrefix( argument, "p" ) ); assert( param.arraySizes.size() == 1 );
if ( param.optional ) assert( param.type.isValue() );
{ assert( param.type.prefix == "const" );
argument = "static_cast<" + param.type.compose() + ">( " + argument + " )"; argument = "reinterpret_cast<const " + param.type.type + "*>( " + argument + " )";
} }
else else if ( param.type.isValue() )
{ {
argument = "&" + argument; argument = "static_cast<" + param.type.type + ">( " + argument + " )";
} }
else
{
assert( !param.type.postfix.empty() );
if ( enhanced )
{
argument = startLowerCase( stripPrefix( argument, "p" ) );
if ( param.optional )
{
argument = "static_cast<" + param.type.compose() + ">( " + argument + " )";
}
else
{
argument = "&" + argument;
}
}
argument = "reinterpret_cast<" + ( param.type.prefix.empty() ? "" : param.type.prefix ) + " " +
param.type.type + " " + param.type.postfix + ">( " + argument + " )";
} }
argument = "reinterpret_cast<" + ( param.type.prefix.empty() ? "" : param.type.prefix ) + " " + param.type.type +
" " + param.type.postfix + ">( " + argument + " )";
} }
} }
return argument; return argument;
@ -3872,8 +3925,6 @@ std::string
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
bool vectorAsNullptr ) const bool vectorAsNullptr ) const
{ {
assert( vectorParamIndices.size() == 2 );
size_t countIndex = vectorParamIndices.begin()->second; size_t countIndex = vectorParamIndices.begin()->second;
assert( ( vectorParamIndices.size() != 2 ) || ( std::next( vectorParamIndices.begin() )->second == countIndex ) ); assert( ( vectorParamIndices.size() != 2 ) || ( std::next( vectorParamIndices.begin() )->second == countIndex ) );
@ -3894,9 +3945,20 @@ std::string
} }
else else
{ {
arguments += "reinterpret_cast<" + params[i].type.type + " *>( enumeratedData." + switch ( vectorParamIndices.size() )
( ( vectorParamIndices.find( i ) == vectorParamIndices.begin() ) ? "first" : "second" ) + {
".data() )"; case 1:
assert( beginsWith( params[i].name, "p" ) );
arguments += "reinterpret_cast<" + params[i].type.type + " *>( " +
startLowerCase( stripPrefix( params[i].name, "p" ) ) + ".data() )";
break;
case 2:
arguments += "reinterpret_cast<" + params[i].type.type + " *>( enumeratedData." +
( ( vectorParamIndices.find( i ) == vectorParamIndices.begin() ) ? "first" : "second" ) +
".data() )";
break;
default: assert( false );
}
} }
} }
else else
@ -4056,9 +4118,8 @@ std::string
startLowerCase( stripPrefix( commandData.params[secondVectorParamIt->first].name, "p" ) ); startLowerCase( stripPrefix( commandData.params[secondVectorParamIt->first].name, "p" ) );
std::string withAllocatorsTypenameCheck = std::string withAllocatorsTypenameCheck =
", typename B1, typename B2, typename std::enable_if < std::is_same<typename B1::value_type, " + ", typename B1, typename B2, typename std::enable_if<std::is_same<typename B1::value_type, " + templateTypeFirst +
templateTypeFirst + ">::value && std::is_same<typename B2::value_type, " + templateTypeSecond + ">::value && std::is_same<typename B2::value_type, " + templateTypeSecond + ">::value, int>::type ";
">::value, int>::type ";
str = replaceWithMap( str = replaceWithMap(
functionTemplate, functionTemplate,
@ -4091,7 +4152,7 @@ std::string
std::string withAllocatorsTypenameCheck = std::string withAllocatorsTypenameCheck =
", typename B1 = " + templateTypeFirst + "Allocator, typename B2 = " + templateTypeSecond + ", typename B1 = " + templateTypeFirst + "Allocator, typename B2 = " + templateTypeSecond +
"Allocator, typename std::enable_if < std::is_same<typename B1::value_type, " + templateTypeFirst + "Allocator, typename std::enable_if<std::is_same<typename B1::value_type, " + templateTypeFirst +
">::value && std::is_same<typename B2::value_type, " + templateTypeSecond + ">::value, int>::type = 0"; ">::value && std::is_same<typename B2::value_type, " + templateTypeSecond + ">::value, int>::type = 0";
str = replaceWithMap( functionTemplate, str = replaceWithMap( functionTemplate,
@ -4184,6 +4245,79 @@ std::string VulkanHppGenerator::constructCommandEnumerateTwoVectorsDeprecated(
return str; return str;
} }
std::string VulkanHppGenerator::constructCommandEnumerateVoid( std::string const & name,
CommandData const & commandData,
std::pair<size_t, size_t> const & vectorParamIndex,
bool definition,
bool withAllocators ) const
{
assert( commandData.params[0].type.type == commandData.handle );
std::string str;
std::string argumentList = constructArgumentListEnhanced(
commandData.params, { 0, vectorParamIndex.second, vectorParamIndex.first }, definition, withAllocators );
std::string commandName = determineCommandName( name, commandData.params[0].type.type );
std::string vectorElementType = stripPrefix( commandData.params[vectorParamIndex.first].type.type, "Vk" );
if ( definition )
{
const std::string functionTemplate =
R"( template <typename ${vectorElementType}Allocator, typename Dispatch${withAllocatorTypenameCheck}>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${vectorElementType}, ${vectorElementType}Allocator> ${className}::${commandName}( ${argumentList} ) const
{
std::vector<${vectorElementType}, ${vectorElementType}Allocator> ${vectorName}${vectorAllocator};
${counterType} ${counterName};
d.${vkCommand}( ${firstCallArguments} );
${vectorName}.resize( ${counterName} );
d.${vkCommand}( ${secondCallArguments} );
VULKAN_HPP_ASSERT( ${counterName} <= ${vectorName}.size() );
return ${vectorName};
})";
std::string withAllocatorsTypenameCheck =
", typename B, typename std::enable_if<std::is_same<typename B::value_type, " + vectorElementType +
">::value, int>::type ";
str = replaceWithMap(
functionTemplate,
std::map<std::string, std::string>(
{ { "argumentList", argumentList },
{ "className", stripPrefix( commandData.handle, "Vk" ) },
{ "commandName", commandName },
{ "counterName", startLowerCase( stripPrefix( commandData.params[vectorParamIndex.second].name, "p" ) ) },
{ "counterType", commandData.params[vectorParamIndex.second].type.type },
{ "firstCallArguments",
constructCallArgumentsEnumerateVectors( commandData.params, { vectorParamIndex }, true ) },
{ "secondCallArguments",
constructCallArgumentsEnumerateVectors( commandData.params, { vectorParamIndex }, false ) },
{ "vectorAllocator", withAllocators ? ( "( " + vectorElementType + "Allocator )" ) : "" },
{ "vectorElementType", vectorElementType },
{ "vectorName", startLowerCase( stripPrefix( commandData.params[vectorParamIndex.first].name, "p" ) ) },
{ "vkCommand", name },
{ "withAllocatorTypenameCheck", withAllocators ? withAllocatorsTypenameCheck : "" } } ) );
}
else
{
const std::string functionTemplate =
R"( template <typename ${vectorElementType}Allocator = std::allocator<${vectorElementType}>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${withAllocatorTypenameCheck}>
VULKAN_HPP_NODISCARD std::vector<${vectorElementType}, ${vectorElementType}Allocator> ${commandName}( ${argumentList} ) const;)";
std::string withAllocatorsTypenameCheck =
", typename B = " + vectorElementType +
"Allocator, typename std::enable_if<std::is_same<typename B::value_type, " + vectorElementType +
">::value, int>::type = 0";
str = replaceWithMap( functionTemplate,
std::map<std::string, std::string>(
{ { "argumentList", argumentList },
{ "commandName", commandName },
{ "vectorElementType", vectorElementType },
{ "withAllocatorTypenameCheck", withAllocators ? withAllocatorsTypenameCheck : "" } } ) );
}
return str;
}
std::string VulkanHppGenerator::constructCommandGetVector( std::string const & name, std::string VulkanHppGenerator::constructCommandGetVector( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
@ -6362,6 +6496,36 @@ std::map<size_t, size_t> VulkanHppGenerator::determineVectorParamIndices( std::v
return vectorParamIndices; return vectorParamIndices;
} }
std::map<size_t, size_t>
VulkanHppGenerator::determineVectorParamIndicesNew( std::vector<ParamData> const & params ) const
{
std::map<size_t, size_t> vectorParamIndices;
// look for the parameters whose len equals the name of an other parameter
for ( auto it = params.begin(); it != params.end(); ++it )
{
if ( !it->len.empty() )
{
auto findLambda = [it]( ParamData const & pd ) {
return pd.name == it->len;
};
auto findIt =
std::find_if( params.begin(), it, findLambda ); // look for a parameter named as the len of this parameter
assert( ( std::count_if( params.begin(), params.end(), findLambda ) == 0 ) ||
( findIt < it ) ); // make sure, there is no other parameter like that
if ( findIt < it )
{
// add this parameter as a vector parameter, using the len-name parameter as the second value (or
// INVALID_INDEX if there is nothing like that)
vectorParamIndices.insert(
std::make_pair( std::distance( params.begin(), it ), std::distance( params.begin(), findIt ) ) );
}
}
}
return vectorParamIndices;
}
void VulkanHppGenerator::appendIndexTypeTraits( std::string & str ) const void VulkanHppGenerator::appendIndexTypeTraits( std::string & str ) const
{ {
auto indexType = m_enums.find( "VkIndexType" ); auto indexType = m_enums.find( "VkIndexType" );

11
VulkanHppGenerator.hpp
View File

@ -321,6 +321,11 @@ private:
CommandData const & commandData, CommandData const & commandData,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
bool definition ) const; bool definition ) const;
void appendCommandEnumerateVoid( std::string & str,
std::string const & name,
CommandData const & commandData,
std::pair<size_t, size_t> const & vectorParamIndex,
bool definition ) const;
void appendCommandGetVector( std::string & str, void appendCommandGetVector( std::string & str,
std::string const & name, std::string const & name,
CommandData const & commandData, CommandData const & commandData,
@ -553,6 +558,11 @@ private:
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
bool definition, bool definition,
bool withAllocators ) const; bool withAllocators ) const;
std::string constructCommandEnumerateVoid( std::string const & name,
CommandData const & commandData,
std::pair<size_t, size_t> const & vectorParamIndex,
bool definition,
bool withAllocators ) const;
std::string constructCommandGetVector( std::string const & name, std::string constructCommandGetVector( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
@ -635,6 +645,7 @@ private:
std::vector<size_t> determineConstPointerParamIndices( std::vector<ParamData> const & params ) const; std::vector<size_t> determineConstPointerParamIndices( std::vector<ParamData> const & params ) const;
std::vector<size_t> determineNonConstPointerParamIndices( std::vector<ParamData> const & params ) const; std::vector<size_t> determineNonConstPointerParamIndices( std::vector<ParamData> const & params ) const;
std::map<size_t, size_t> determineVectorParamIndices( std::vector<ParamData> const & params ) const; std::map<size_t, size_t> determineVectorParamIndices( std::vector<ParamData> const & params ) const;
std::map<size_t, size_t> determineVectorParamIndicesNew( std::vector<ParamData> const & params ) const;
std::string generateLenInitializer( std::string generateLenInitializer(
std::vector<MemberData>::const_iterator mit, std::vector<MemberData>::const_iterator mit,
std::map<std::vector<MemberData>::const_iterator, std::map<std::vector<MemberData>::const_iterator,

480
vulkan/vulkan.hpp
View File

@ -47719,21 +47719,22 @@ namespace VULKAN_HPP_NAMESPACE
#endif #endif
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getCheckpointDataNV( uint32_t * pCheckpointDataCount, void getCheckpointDataNV( uint32_t * pCheckpointDataCount,
VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData, VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData
VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
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 Allocator = std::allocator<CheckpointDataNV>, template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<CheckpointDataNV, Allocator> VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Allocator = std::allocator<CheckpointDataNV>, template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = Allocator, typename B = CheckpointDataNVAllocator,
typename std::enable_if<std::is_same<typename B::value_type, CheckpointDataNV>::value, int>::type = 0> typename std::enable_if<std::is_same<typename B::value_type, CheckpointDataNV>::value, int>::type = 0>
std::vector<CheckpointDataNV, Allocator> VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
getCheckpointDataNV( Allocator const & vectorAllocator, getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataAllocator,
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*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@ -54507,71 +54508,74 @@ namespace VULKAN_HPP_NAMESPACE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getImageSparseMemoryRequirements( void getImageSparseMemoryRequirements(
VULKAN_HPP_NAMESPACE::Image image, VULKAN_HPP_NAMESPACE::Image image,
uint32_t * pSparseMemoryRequirementCount, uint32_t * pSparseMemoryRequirementCount,
VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements
VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
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 Allocator = std::allocator<SparseImageMemoryRequirements>, template <typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<SparseImageMemoryRequirements, Allocator> VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Allocator = std::allocator<SparseImageMemoryRequirements>, template <typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = Allocator, typename B = SparseImageMemoryRequirementsAllocator,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value, typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value,
int>::type = 0> int>::type = 0>
std::vector<SparseImageMemoryRequirements, Allocator> VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
Allocator const & vectorAllocator, SparseImageMemoryRequirementsAllocator & sparseMemoryRequirementsAllocator,
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*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getImageSparseMemoryRequirements2( void getImageSparseMemoryRequirements2(
const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo, const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
uint32_t * pSparseMemoryRequirementCount, uint32_t * pSparseMemoryRequirementCount,
VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements
VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
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 Allocator = std::allocator<SparseImageMemoryRequirements2>, template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<SparseImageMemoryRequirements2, Allocator> VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>, template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = Allocator, typename B = SparseImageMemoryRequirements2Allocator,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value, typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
int>::type = 0> int>::type = 0>
std::vector<SparseImageMemoryRequirements2, Allocator> VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
Allocator const & vectorAllocator, SparseImageMemoryRequirements2Allocator & sparseMemoryRequirementsAllocator,
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*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getImageSparseMemoryRequirements2KHR( void getImageSparseMemoryRequirements2KHR(
const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo, const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
uint32_t * pSparseMemoryRequirementCount, uint32_t * pSparseMemoryRequirementCount,
VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements
VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
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 Allocator = std::allocator<SparseImageMemoryRequirements2>, template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<SparseImageMemoryRequirements2, Allocator> VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>, template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = Allocator, typename B = SparseImageMemoryRequirements2Allocator,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value, typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
int>::type = 0> int>::type = 0>
std::vector<SparseImageMemoryRequirements2, Allocator> VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
Allocator const & vectorAllocator, SparseImageMemoryRequirements2Allocator & sparseMemoryRequirementsAllocator,
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*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@ -60911,23 +60915,23 @@ namespace VULKAN_HPP_NAMESPACE
#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>
void void getQueueFamilyProperties(
getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount, uint32_t * pQueueFamilyPropertyCount,
VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties, VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
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 Allocator = std::allocator<QueueFamilyProperties>, template <typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<QueueFamilyProperties, Allocator> VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template < template <
typename Allocator = std::allocator<QueueFamilyProperties>, typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = Allocator, typename B = QueueFamilyPropertiesAllocator,
typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type = 0> typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type = 0>
std::vector<QueueFamilyProperties, Allocator> VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
getQueueFamilyProperties( Allocator const & vectorAllocator, getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
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*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@ -60997,84 +61001,84 @@ namespace VULKAN_HPP_NAMESPACE
#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>
void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, void getSparseImageFormatProperties(
VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ImageType type,
VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
uint32_t * pPropertyCount, VULKAN_HPP_NAMESPACE::ImageTiling tiling,
VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties, uint32_t * pPropertyCount,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
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 Allocator = std::allocator<SparseImageFormatProperties>, template <typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<SparseImageFormatProperties, Allocator> VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageType type,
VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageTiling tiling,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template < template <
typename Allocator = std::allocator<SparseImageFormatProperties>, typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = Allocator, typename B = SparseImageFormatPropertiesAllocator,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties>::value, int>::type = 0> typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties>::value, int>::type = 0>
std::vector<SparseImageFormatProperties, Allocator> VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageType type,
VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageTiling tiling,
Allocator const & vectorAllocator, SparseImageFormatPropertiesAllocator & propertiesAllocator,
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*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getSparseImageFormatProperties2( void getSparseImageFormatProperties2(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
uint32_t * pPropertyCount, uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
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 Allocator = std::allocator<SparseImageFormatProperties2>, template <typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<SparseImageFormatProperties2, Allocator> VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template < template <
typename Allocator = std::allocator<SparseImageFormatProperties2>, typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = Allocator, typename B = SparseImageFormatProperties2Allocator,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0> typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
std::vector<SparseImageFormatProperties2, Allocator> VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
Allocator const & vectorAllocator, SparseImageFormatProperties2Allocator & propertiesAllocator,
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*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void getSparseImageFormatProperties2KHR( void getSparseImageFormatProperties2KHR(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
uint32_t * pPropertyCount, uint32_t * pPropertyCount,
VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
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 Allocator = std::allocator<SparseImageFormatProperties2>, template <typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
std::vector<SparseImageFormatProperties2, Allocator> VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template < template <
typename Allocator = std::allocator<SparseImageFormatProperties2>, typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename B = Allocator, typename B = SparseImageFormatProperties2Allocator,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0> typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
std::vector<SparseImageFormatProperties2, Allocator> VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
Allocator const & vectorAllocator, SparseImageFormatProperties2Allocator & propertiesAllocator,
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*/
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@ -97612,13 +97616,15 @@ namespace VULKAN_HPP_NAMESPACE
pSparseMemoryRequirementCount, pSparseMemoryRequirementCount,
reinterpret_cast<VkSparseImageMemoryRequirements *>( pSparseMemoryRequirements ) ); reinterpret_cast<VkSparseImageMemoryRequirements *>( pSparseMemoryRequirements ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator, typename Dispatch> template <typename SparseImageMemoryRequirementsAllocator, typename Dispatch>
VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, Allocator> VULKAN_HPP_NODISCARD
Device::getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
Device::getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d ) const
{ {
std::vector<SparseImageMemoryRequirements, Allocator> sparseMemoryRequirements; std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> sparseMemoryRequirements;
uint32_t sparseMemoryRequirementCount; uint32_t sparseMemoryRequirementCount;
d.vkGetImageSparseMemoryRequirements( d.vkGetImageSparseMemoryRequirements(
m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr ); m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
@ -97627,18 +97633,25 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkImage>( image ), static_cast<VkImage>( image ),
&sparseMemoryRequirementCount, &sparseMemoryRequirementCount,
reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) ); reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
return sparseMemoryRequirements; return sparseMemoryRequirements;
} }
template < template <
typename Allocator, typename SparseImageMemoryRequirementsAllocator,
typename Dispatch, typename Dispatch,
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value, int>::type>
VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, Allocator> Device::getImageSparseMemoryRequirements( VULKAN_HPP_NODISCARD
VULKAN_HPP_NAMESPACE::Image image, Allocator const & vectorAllocator, Dispatch const & d ) const VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
Device::getImageSparseMemoryRequirements(
VULKAN_HPP_NAMESPACE::Image image,
SparseImageMemoryRequirementsAllocator & sparseMemoryRequirementsAllocator,
Dispatch const & d ) const
{ {
std::vector<SparseImageMemoryRequirements, Allocator> sparseMemoryRequirements( vectorAllocator ); std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator> sparseMemoryRequirements(
uint32_t sparseMemoryRequirementCount; SparseImageMemoryRequirementsAllocator );
uint32_t sparseMemoryRequirementCount;
d.vkGetImageSparseMemoryRequirements( d.vkGetImageSparseMemoryRequirements(
m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr ); m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
@ -97647,6 +97660,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkImage>( image ), static_cast<VkImage>( image ),
&sparseMemoryRequirementCount, &sparseMemoryRequirementCount,
reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) ); reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
return sparseMemoryRequirements; return sparseMemoryRequirements;
} }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -97664,14 +97678,16 @@ namespace VULKAN_HPP_NAMESPACE
pSparseMemoryRequirementCount, pSparseMemoryRequirementCount,
reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) ); reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator, typename Dispatch> template <typename SparseImageMemoryRequirements2Allocator, typename Dispatch>
VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, Allocator> VULKAN_HPP_NODISCARD
Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
Dispatch const & d ) const Dispatch const & d ) const
{ {
std::vector<SparseImageMemoryRequirements2, Allocator> sparseMemoryRequirements; std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
uint32_t sparseMemoryRequirementCount; uint32_t sparseMemoryRequirementCount;
d.vkGetImageSparseMemoryRequirements2( m_device, d.vkGetImageSparseMemoryRequirements2( m_device,
reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
&sparseMemoryRequirementCount, &sparseMemoryRequirementCount,
@ -97682,18 +97698,25 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
&sparseMemoryRequirementCount, &sparseMemoryRequirementCount,
reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
return sparseMemoryRequirements; return sparseMemoryRequirements;
} }
template < template <
typename Allocator, typename SparseImageMemoryRequirements2Allocator,
typename Dispatch, typename Dispatch,
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value, int>::type>
VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, Allocator> Device::getImageSparseMemoryRequirements2( VULKAN_HPP_NODISCARD
const ImageSparseMemoryRequirementsInfo2 & info, Allocator const & vectorAllocator, Dispatch const & d ) const VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
Device::getImageSparseMemoryRequirements2(
const ImageSparseMemoryRequirementsInfo2 & info,
SparseImageMemoryRequirements2Allocator & sparseMemoryRequirementsAllocator,
Dispatch const & d ) const
{ {
std::vector<SparseImageMemoryRequirements2, Allocator> sparseMemoryRequirements( vectorAllocator ); std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements(
uint32_t sparseMemoryRequirementCount; SparseImageMemoryRequirements2Allocator );
uint32_t sparseMemoryRequirementCount;
d.vkGetImageSparseMemoryRequirements2( m_device, d.vkGetImageSparseMemoryRequirements2( m_device,
reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
&sparseMemoryRequirementCount, &sparseMemoryRequirementCount,
@ -97704,6 +97727,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
&sparseMemoryRequirementCount, &sparseMemoryRequirementCount,
reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
return sparseMemoryRequirements; return sparseMemoryRequirements;
} }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -97721,14 +97745,16 @@ namespace VULKAN_HPP_NAMESPACE
pSparseMemoryRequirementCount, pSparseMemoryRequirementCount,
reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) ); reinterpret_cast<VkSparseImageMemoryRequirements2 *>( pSparseMemoryRequirements ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator, typename Dispatch> template <typename SparseImageMemoryRequirements2Allocator, typename Dispatch>
VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, Allocator> VULKAN_HPP_NODISCARD
Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
Dispatch const & d ) const Dispatch const & d ) const
{ {
std::vector<SparseImageMemoryRequirements2, Allocator> sparseMemoryRequirements; std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements;
uint32_t sparseMemoryRequirementCount; uint32_t sparseMemoryRequirementCount;
d.vkGetImageSparseMemoryRequirements2KHR( m_device, d.vkGetImageSparseMemoryRequirements2KHR( m_device,
reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
&sparseMemoryRequirementCount, &sparseMemoryRequirementCount,
@ -97739,18 +97765,25 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
&sparseMemoryRequirementCount, &sparseMemoryRequirementCount,
reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
return sparseMemoryRequirements; return sparseMemoryRequirements;
} }
template < template <
typename Allocator, typename SparseImageMemoryRequirements2Allocator,
typename Dispatch, typename Dispatch,
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value, int>::type>
VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, Allocator> Device::getImageSparseMemoryRequirements2KHR( VULKAN_HPP_NODISCARD
const ImageSparseMemoryRequirementsInfo2 & info, Allocator const & vectorAllocator, Dispatch const & d ) const VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
Device::getImageSparseMemoryRequirements2KHR(
const ImageSparseMemoryRequirementsInfo2 & info,
SparseImageMemoryRequirements2Allocator & sparseMemoryRequirementsAllocator,
Dispatch const & d ) const
{ {
std::vector<SparseImageMemoryRequirements2, Allocator> sparseMemoryRequirements( vectorAllocator ); std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator> sparseMemoryRequirements(
uint32_t sparseMemoryRequirementCount; SparseImageMemoryRequirements2Allocator );
uint32_t sparseMemoryRequirementCount;
d.vkGetImageSparseMemoryRequirements2KHR( m_device, d.vkGetImageSparseMemoryRequirements2KHR( m_device,
reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
&sparseMemoryRequirementCount, &sparseMemoryRequirementCount,
@ -97761,6 +97794,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
&sparseMemoryRequirementCount, &sparseMemoryRequirementCount,
reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
return sparseMemoryRequirements; return sparseMemoryRequirements;
} }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -103362,36 +103396,42 @@ namespace VULKAN_HPP_NAMESPACE
pQueueFamilyPropertyCount, pQueueFamilyPropertyCount,
reinterpret_cast<VkQueueFamilyProperties *>( pQueueFamilyProperties ) ); reinterpret_cast<VkQueueFamilyProperties *>( pQueueFamilyProperties ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator, typename Dispatch> template <typename QueueFamilyPropertiesAllocator, typename Dispatch>
VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, Allocator> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
PhysicalDevice::getQueueFamilyProperties( Dispatch const & d ) const PhysicalDevice::getQueueFamilyProperties( Dispatch const & d ) const
{ {
std::vector<QueueFamilyProperties, Allocator> queueFamilyProperties; std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator> queueFamilyProperties;
uint32_t queueFamilyPropertyCount; uint32_t queueFamilyPropertyCount;
d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
queueFamilyProperties.resize( queueFamilyPropertyCount ); queueFamilyProperties.resize( queueFamilyPropertyCount );
d.vkGetPhysicalDeviceQueueFamilyProperties( d.vkGetPhysicalDeviceQueueFamilyProperties(
m_physicalDevice, m_physicalDevice,
&queueFamilyPropertyCount, &queueFamilyPropertyCount,
reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) ); reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) );
VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
return queueFamilyProperties; return queueFamilyProperties;
} }
template <typename Allocator,
template <typename QueueFamilyPropertiesAllocator,
typename Dispatch, typename Dispatch,
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type>
VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, Allocator> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
PhysicalDevice::getQueueFamilyProperties( Allocator const & vectorAllocator, Dispatch const & d ) const PhysicalDevice::getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
Dispatch const & d ) const
{ {
std::vector<QueueFamilyProperties, Allocator> queueFamilyProperties( vectorAllocator ); std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator> queueFamilyProperties(
uint32_t queueFamilyPropertyCount; QueueFamilyPropertiesAllocator );
uint32_t queueFamilyPropertyCount;
d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
queueFamilyProperties.resize( queueFamilyPropertyCount ); queueFamilyProperties.resize( queueFamilyPropertyCount );
d.vkGetPhysicalDeviceQueueFamilyProperties( d.vkGetPhysicalDeviceQueueFamilyProperties(
m_physicalDevice, m_physicalDevice,
&queueFamilyPropertyCount, &queueFamilyPropertyCount,
reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) ); reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) );
VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
return queueFamilyProperties; return queueFamilyProperties;
} }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -103603,18 +103643,19 @@ namespace VULKAN_HPP_NAMESPACE
pPropertyCount, pPropertyCount,
reinterpret_cast<VkSparseImageFormatProperties *>( pProperties ) ); reinterpret_cast<VkSparseImageFormatProperties *>( pProperties ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator, typename Dispatch> template <typename SparseImageFormatPropertiesAllocator, typename Dispatch>
VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties, Allocator> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageType type,
VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageTiling tiling,
Dispatch const & d ) const Dispatch const & d ) const
{ {
std::vector<SparseImageFormatProperties, Allocator> properties; std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> properties;
uint32_t propertyCount; uint32_t propertyCount;
d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice,
static_cast<VkFormat>( format ), static_cast<VkFormat>( format ),
static_cast<VkImageType>( type ), static_cast<VkImageType>( type ),
@ -103633,24 +103674,27 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkImageTiling>( tiling ), static_cast<VkImageTiling>( tiling ),
&propertyCount, &propertyCount,
reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) ); reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
return properties; return properties;
} }
template < template <
typename Allocator, typename SparseImageFormatPropertiesAllocator,
typename Dispatch, typename Dispatch,
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties>::value, int>::type>
VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties, Allocator> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
VULKAN_HPP_NAMESPACE::ImageType type, VULKAN_HPP_NAMESPACE::ImageType type,
VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
VULKAN_HPP_NAMESPACE::ImageTiling tiling, VULKAN_HPP_NAMESPACE::ImageTiling tiling,
Allocator const & vectorAllocator, SparseImageFormatPropertiesAllocator & propertiesAllocator,
Dispatch const & d ) const Dispatch const & d ) const
{ {
std::vector<SparseImageFormatProperties, Allocator> properties( vectorAllocator ); std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator> properties(
uint32_t propertyCount; SparseImageFormatPropertiesAllocator );
uint32_t propertyCount;
d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice,
static_cast<VkFormat>( format ), static_cast<VkFormat>( format ),
static_cast<VkImageType>( type ), static_cast<VkImageType>( type ),
@ -103669,6 +103713,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkImageTiling>( tiling ), static_cast<VkImageTiling>( tiling ),
&propertyCount, &propertyCount,
reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) ); reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
return properties; return properties;
} }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -103686,14 +103731,16 @@ namespace VULKAN_HPP_NAMESPACE
pPropertyCount, pPropertyCount,
reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) ); reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator, typename Dispatch> template <typename SparseImageFormatProperties2Allocator, typename Dispatch>
VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, Allocator> VULKAN_HPP_NODISCARD
PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
Dispatch const & d ) const Dispatch const & d ) const
{ {
std::vector<SparseImageFormatProperties2, Allocator> properties; std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties;
uint32_t propertyCount; uint32_t propertyCount;
d.vkGetPhysicalDeviceSparseImageFormatProperties2( d.vkGetPhysicalDeviceSparseImageFormatProperties2(
m_physicalDevice, m_physicalDevice,
reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
@ -103705,20 +103752,24 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
&propertyCount, &propertyCount,
reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
return properties; return properties;
} }
template < template <
typename Allocator, typename SparseImageFormatProperties2Allocator,
typename Dispatch, typename Dispatch,
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type>
VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, Allocator> VULKAN_HPP_NODISCARD
PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
Allocator const & vectorAllocator, PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
SparseImageFormatProperties2Allocator & propertiesAllocator,
Dispatch const & d ) const Dispatch const & d ) const
{ {
std::vector<SparseImageFormatProperties2, Allocator> properties( vectorAllocator ); std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties(
uint32_t propertyCount; SparseImageFormatProperties2Allocator );
uint32_t propertyCount;
d.vkGetPhysicalDeviceSparseImageFormatProperties2( d.vkGetPhysicalDeviceSparseImageFormatProperties2(
m_physicalDevice, m_physicalDevice,
reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
@ -103730,6 +103781,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
&propertyCount, &propertyCount,
reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
return properties; return properties;
} }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -103747,14 +103799,16 @@ namespace VULKAN_HPP_NAMESPACE
pPropertyCount, pPropertyCount,
reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) ); reinterpret_cast<VkSparseImageFormatProperties2 *>( pProperties ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator, typename Dispatch> template <typename SparseImageFormatProperties2Allocator, typename Dispatch>
VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, Allocator> VULKAN_HPP_NODISCARD
PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
Dispatch const & d ) const Dispatch const & d ) const
{ {
std::vector<SparseImageFormatProperties2, Allocator> properties; std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties;
uint32_t propertyCount; uint32_t propertyCount;
d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
m_physicalDevice, m_physicalDevice,
reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
@ -103766,20 +103820,24 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
&propertyCount, &propertyCount,
reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
return properties; return properties;
} }
template < template <
typename Allocator, typename SparseImageFormatProperties2Allocator,
typename Dispatch, typename Dispatch,
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type>
VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, Allocator> VULKAN_HPP_NODISCARD
PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
Allocator const & vectorAllocator, PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
Dispatch const & d ) const SparseImageFormatProperties2Allocator & propertiesAllocator,
Dispatch const & d ) const
{ {
std::vector<SparseImageFormatProperties2, Allocator> properties( vectorAllocator ); std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator> properties(
uint32_t propertyCount; SparseImageFormatProperties2Allocator );
uint32_t propertyCount;
d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
m_physicalDevice, m_physicalDevice,
reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
@ -103791,6 +103849,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
&propertyCount, &propertyCount,
reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
return properties; return properties;
} }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -104536,31 +104595,36 @@ namespace VULKAN_HPP_NAMESPACE
d.vkGetQueueCheckpointDataNV( d.vkGetQueueCheckpointDataNV(
m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( pCheckpointData ) ); m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( pCheckpointData ) );
} }
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Allocator, typename Dispatch> template <typename CheckpointDataNVAllocator, typename Dispatch>
VULKAN_HPP_INLINE std::vector<CheckpointDataNV, Allocator> Queue::getCheckpointDataNV( Dispatch const & d ) const VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
Queue::getCheckpointDataNV( Dispatch const & d ) const
{ {
std::vector<CheckpointDataNV, Allocator> checkpointData; std::vector<CheckpointDataNV, CheckpointDataNVAllocator> checkpointData;
uint32_t checkpointDataCount; uint32_t checkpointDataCount;
d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr ); d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
checkpointData.resize( checkpointDataCount ); checkpointData.resize( checkpointDataCount );
d.vkGetQueueCheckpointDataNV( d.vkGetQueueCheckpointDataNV(
m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) ); m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) );
VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
return checkpointData; return checkpointData;
} }
template <typename Allocator,
template <typename CheckpointDataNVAllocator,
typename Dispatch, typename Dispatch,
typename B, typename B,
typename std::enable_if<std::is_same<typename B::value_type, CheckpointDataNV>::value, int>::type> typename std::enable_if<std::is_same<typename B::value_type, CheckpointDataNV>::value, int>::type>
VULKAN_HPP_INLINE std::vector<CheckpointDataNV, Allocator> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
Queue::getCheckpointDataNV( Allocator const & vectorAllocator, Dispatch const & d ) const Queue::getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataAllocator, Dispatch const & d ) const
{ {
std::vector<CheckpointDataNV, Allocator> checkpointData( vectorAllocator ); std::vector<CheckpointDataNV, CheckpointDataNVAllocator> checkpointData( CheckpointDataNVAllocator );
uint32_t checkpointDataCount; uint32_t checkpointDataCount;
d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr ); d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
checkpointData.resize( checkpointDataCount ); checkpointData.resize( checkpointDataCount );
d.vkGetQueueCheckpointDataNV( d.vkGetQueueCheckpointDataNV(
m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) ); m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) );
VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
return checkpointData; return checkpointData;
} }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/