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 #753 from asuessenbach/refactor

Browse Source 
Refactor function generation of void-functions enumerating a single vector of data.
This commit is contained in:
Andreas Süßenbach 2020-09-29 09:37:58 +02:00 committed by GitHub
commit ea0498def9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 488 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

190
VulkanHppGenerator.cpp
View File

@ -1224,7 +1224,7 @@ void VulkanHppGenerator::appendCommand( std::string & str,
bool definition ) const
{
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 );
if ( nonConstPointerParamIndices.empty() )
{
@ -1288,14 +1288,24 @@ void VulkanHppGenerator::appendCommand( std::string & str,
{
// just one vector parameter
auto vectorParamIndexIt = vectorParamIndices.begin();
if ( commandData.params[vectorParamIndexIt->first].type.isNonConstPointer() &&
( commandData.params[vectorParamIndexIt->first].type.type == "void" ) &&
commandData.params[vectorParamIndexIt->second].type.isValue() )
if ( 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 );
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;
case 2:
@ -1342,6 +1352,8 @@ void VulkanHppGenerator::appendCommand( std::string & str,
bool twoStep = isTwoStepAlgorithm( commandData.params );
vectorParamIndices =
determineVectorParamIndices( commandData.params ); // determine vector param indices the old way again
size_t returnParamIndex = determineReturnParamIndex( commandData, vectorParamIndices, twoStep );
bool isStructureChain =
( returnParamIndex != INVALID_INDEX ) &&
@ -1625,6 +1637,36 @@ ${commandEnhancedWithAllocators}
{ "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,
std::string const & name,
CommandData const & commandData,
@ -3821,7 +3863,17 @@ std::string VulkanHppGenerator::constructArgumentListStandard( std::vector<Param
std::string VulkanHppGenerator::constructCallArgument( ParamData const & param, bool enhanced ) const
{
std::string argument = param.name;
std::string argument;
if ( enhanced && param.len == "null-terminated" )
{
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" ) )
{
if ( !param.arraySizes.empty() )
@ -3850,8 +3902,9 @@ std::string VulkanHppGenerator::constructCallArgument( ParamData const & param,
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;
@ -3872,8 +3925,6 @@ std::string
std::map<size_t, size_t> const & vectorParamIndices,
bool vectorAsNullptr ) const
{
assert( vectorParamIndices.size() == 2 );
size_t countIndex = vectorParamIndices.begin()->second;
assert( ( vectorParamIndices.size() != 2 ) || ( std::next( vectorParamIndices.begin() )->second == countIndex ) );
@ -3894,9 +3945,20 @@ std::string
}
else
{
switch ( vectorParamIndices.size() )
{
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
@ -4056,9 +4118,8 @@ std::string
startLowerCase( stripPrefix( commandData.params[secondVectorParamIt->first].name, "p" ) );
std::string withAllocatorsTypenameCheck =
", typename B1, typename B2, typename std::enable_if < std::is_same<typename B1::value_type, " +
templateTypeFirst + ">::value && std::is_same<typename B2::value_type, " + templateTypeSecond +
">::value, int>::type ";
", typename B1, typename B2, typename std::enable_if<std::is_same<typename B1::value_type, " + templateTypeFirst +
">::value && std::is_same<typename B2::value_type, " + templateTypeSecond + ">::value, int>::type ";
str = replaceWithMap(
functionTemplate,
@ -4184,6 +4245,79 @@ std::string VulkanHppGenerator::constructCommandEnumerateTwoVectorsDeprecated(
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,
CommandData const & commandData,
std::map<size_t, size_t> const & vectorParamIndices,
@ -6362,6 +6496,36 @@ std::map<size_t, size_t> VulkanHppGenerator::determineVectorParamIndices( std::v
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
{
auto indexType = m_enums.find( "VkIndexType" );

11
VulkanHppGenerator.hpp
View File

@ -321,6 +321,11 @@ private:
CommandData const & commandData,
std::map<size_t, size_t> const & vectorParamIndices,
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,
std::string const & name,
CommandData const & commandData,
@ -553,6 +558,11 @@ private:
std::map<size_t, size_t> const & vectorParamIndices,
bool definition,
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,
CommandData const & commandData,
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> 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> determineVectorParamIndicesNew( std::vector<ParamData> const & params ) const;
std::string generateLenInitializer(
std::vector<MemberData>::const_iterator mit,
std::map<std::vector<MemberData>::const_iterator,

298
vulkan/vulkan.hpp
View File

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