mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-09-20 05:52:16 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Combine two types of commands into one generation function

Browse Source
This commit is contained in:
asuessenbach 2022-06-14 10:53:50 +02:00
parent dd52513e90
commit 66fc081783
3 changed files with 195 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
VulkanHppGenerator.cpp
View File

@ -1912,7 +1912,8 @@ std::string VulkanHppGenerator::combineDataTypes( std::map<size_t, size_t> const
std::vector<size_t> const & returnParams, std::vector<size_t> const & returnParams,
bool singular, bool singular,
bool enumerating, bool enumerating,
std::vector<std::string> const & dataTypes ) const std::vector<std::string> const & dataTypes,
bool raii ) const
{ {
assert( dataTypes.size() == returnParams.size() ); assert( dataTypes.size() == returnParams.size() );
@ -1922,7 +1923,8 @@ std::string VulkanHppGenerator::combineDataTypes( std::map<size_t, size_t> const
auto vectorParamIt = vectorParams.find( returnParams[i] ); auto vectorParamIt = vectorParams.find( returnParams[i] );
modifiedDataTypes[i] = ( vectorParamIt == vectorParams.end() || singular ) modifiedDataTypes[i] = ( vectorParamIt == vectorParams.end() || singular )
? dataTypes[i] ? dataTypes[i]
: ( "std::vector<" + dataTypes[i] + ", " + startUpperCase( stripPrefix( dataTypes[i], "VULKAN_HPP_NAMESPACE::" ) ) + "Allocator>" ); : ( "std::vector<" + dataTypes[i] +
( raii ? ">" : ( ", " + startUpperCase( stripPrefix( dataTypes[i], "VULKAN_HPP_NAMESPACE::" ) ) + "Allocator>" ) ) );
} }
std::string combinedType; std::string combinedType;
@ -3155,8 +3157,8 @@ std::string VulkanHppGenerator::generateCallSequence( std::string const &
auto vectorParamIt = vectorParams.find( returnParams[1] ); auto vectorParamIt = vectorParams.find( returnParams[1] );
assert( ( vectorParamIt != vectorParams.end() ) && ( vectorParamIt->second == returnParams[0] ) ); assert( ( vectorParamIt != vectorParams.end() ) && ( vectorParamIt->second == returnParams[0] ) );
std::string firstCallArguments = generateCallArgumentsEnhanced( commandData, initialSkipCount, true, {}, templatedParams, false ); std::string firstCallArguments = generateCallArgumentsEnhanced( commandData, initialSkipCount, true, {}, templatedParams, raii );
std::string secondCallArguments = generateCallArgumentsEnhanced( commandData, initialSkipCount, false, {}, templatedParams, false ); std::string secondCallArguments = generateCallArgumentsEnhanced( commandData, initialSkipCount, false, {}, templatedParams, raii );
std::string vectorName = startLowerCase( stripPrefix( commandData.params[vectorParamIt->first].name, "p" ) ); std::string vectorName = startLowerCase( stripPrefix( commandData.params[vectorParamIt->first].name, "p" ) );
std::string vectorSize = startLowerCase( stripPrefix( commandData.params[vectorParamIt->second].name, "p" ) ); std::string vectorSize = startLowerCase( stripPrefix( commandData.params[vectorParamIt->second].name, "p" ) );
@ -3444,7 +3446,7 @@ std::string VulkanHppGenerator::generateCommandEnhanced( std::string const &
bool enumerating = determineEnumeration( vectorParams, returnParams ); bool enumerating = determineEnumeration( vectorParams, returnParams );
std::vector<std::string> dataTypes = determineDataTypes( commandData.params, vectorParams, returnParams, templatedParams ); std::vector<std::string> dataTypes = determineDataTypes( commandData.params, vectorParams, returnParams, templatedParams );
std::string dataType = combineDataTypes( vectorParams, returnParams, singular, enumerating, dataTypes ); std::string dataType = combineDataTypes( vectorParams, returnParams, singular, enumerating, dataTypes, false );
std::string argumentTemplates = generateArgumentTemplates( commandData.params, returnParams, vectorParams, templatedParams, chained, false ); std::string argumentTemplates = generateArgumentTemplates( commandData.params, returnParams, vectorParams, templatedParams, chained, false );
auto [allocatorTemplates, uniqueHandleAllocatorTemplates] = auto [allocatorTemplates, uniqueHandleAllocatorTemplates] =
@ -6141,7 +6143,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandEnhanced( std::map<std:
bool enumerating = determineEnumeration( vectorParams, returnParams ); bool enumerating = determineEnumeration( vectorParams, returnParams );
std::vector<std::string> dataTypes = determineDataTypes( commandIt->second.params, vectorParams, returnParams, templatedParams ); std::vector<std::string> dataTypes = determineDataTypes( commandIt->second.params, vectorParams, returnParams, templatedParams );
std::string dataType = combineDataTypes( vectorParams, returnParams, false, enumerating, dataTypes ); std::string dataType = combineDataTypes( vectorParams, returnParams, false, enumerating, dataTypes, true );
std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, returnParams, vectorParams, templatedParams, chained, true ); std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, returnParams, vectorParams, templatedParams, chained, true );
std::string argumentList = std::string argumentList =
@ -6168,6 +6170,7 @@ ${vectorSizeCheck}
${dataDeclarations} ${dataDeclarations}
${callSequence} ${callSequence}
${resultCheck} ${resultCheck}
${dataPreparation}
${returnStatement} ${returnStatement}
} }
)"; )";
@ -6178,6 +6181,8 @@ ${vectorSizeCheck}
std::string returnVariable = generateReturnVariable( commandIt->second, returnParams, vectorParams, chained, false ); std::string returnVariable = generateReturnVariable( commandIt->second, returnParams, vectorParams, chained, false );
std::string dataDeclarations = generateDataDeclarations( std::string dataDeclarations = generateDataDeclarations(
commandIt->second, returnParams, vectorParams, templatedParams, false, false, chained, false, dataTypes, dataType, returnType, returnVariable ); commandIt->second, returnParams, vectorParams, templatedParams, false, false, chained, false, dataTypes, dataType, returnType, returnVariable );
std::string dataPreparation =
generateDataPreparation( commandIt->second, initialSkipCount, returnParams, vectorParams, templatedParams, false, false, false, chained, enumerating );
std::string resultCheck = generateResultCheck( commandIt->second, className, "::", commandName, enumerating ); std::string resultCheck = generateResultCheck( commandIt->second, className, "::", commandName, enumerating );
std::string returnStatement = generateReturnStatement( commandIt->first, std::string returnStatement = generateReturnStatement( commandIt->first,
commandIt->second, commandIt->second,
@ -6200,6 +6205,7 @@ ${vectorSizeCheck}
{ "className", className }, { "className", className },
{ "commandName", commandName }, { "commandName", commandName },
{ "dataDeclarations", dataDeclarations }, { "dataDeclarations", dataDeclarations },
{ "dataPreparation", dataPreparation },
{ "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) }, { "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
{ "noexcept", noexceptString }, { "noexcept", noexceptString },
@ -7787,7 +7793,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid( std::map<std::str
{ {
if ( returnParams[1] == vectorParams.begin()->first ) if ( returnParams[1] == vectorParams.begin()->first )
{ {
str = generateRAIIHandleCommandVoid2ReturnEnumerateValue( commandIt, initialSkipCount, vectorParams, returnParams, definition ); str = generateRAIIHandleCommandEnhanced( commandIt, initialSkipCount, returnParams, vectorParams, definition, false );
if ( isStructureChainAnchor( commandIt->second.params[returnParams[1]].type.type ) ) if ( isStructureChainAnchor( commandIt->second.params[returnParams[1]].type.type ) )
{ {
str += generateRAIIHandleCommandVoid2ReturnEnumerateChain( commandIt, initialSkipCount, vectorParams, returnParams, definition ); str += generateRAIIHandleCommandVoid2ReturnEnumerateChain( commandIt, initialSkipCount, vectorParams, returnParams, definition );
@ -7991,87 +7997,6 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid2ReturnEnumerateCha
} }
} }
std::string VulkanHppGenerator::generateRAIIHandleCommandVoid2ReturnEnumerateValue( std::map<std::string, CommandData>::const_iterator commandIt,
size_t initialSkipCount,
std::map<size_t, size_t> const & vectorParams,
std::vector<size_t> const & returnParams,
bool definition ) const
{
std::set<size_t> skippedParams = determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, returnParams, false );
std::set<size_t> templatedParams = determineVoidPointerParams( commandIt->second.params );
std::string argumentList =
generateArgumentListEnhanced( commandIt->second.params, returnParams, vectorParams, skippedParams, {}, templatedParams, definition, false, false, false );
std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, returnParams, vectorParams, templatedParams, false, true );
std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags, false, false );
std::string vectorElementType = ( templatedParams.find( vectorParams.begin()->first ) == templatedParams.end() )
? stripPostfix( commandIt->second.params[vectorParams.begin()->first].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" )
: ( stripPrefix( commandIt->second.params[vectorParams.begin()->first].name, "p" ) + "Type" );
if ( definition )
{
const std::string definitionTemplate =
R"(
${argumentTemplates}
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<${vectorElementType}> ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
{${functionPointerCheck}
${counterType} ${counterName};
getDispatcher()->${vkCommand}( ${firstCallArguments} );${templateArgumentSizeAssert}
std::vector<${vectorElementType}> ${vectorName}( ${vectorSize} );
getDispatcher()->${vkCommand}( ${secondCallArguments} );
VULKAN_HPP_ASSERT( ${counterName} == ${vectorName}.size()${timesTemplateTypeSize} );
return ${vectorName};
}
)";
std::string counterName = startLowerCase( stripPrefix( commandIt->second.params[vectorParams.begin()->second].name, "p" ) );
std::string firstCallArguments = generateCallArgumentsEnhanced( commandIt->second, initialSkipCount, true, {}, templatedParams, true );
std::string secondCallArguments = generateCallArgumentsEnhanced( commandIt->second, initialSkipCount, false, {}, templatedParams, true );
std::string templateArgumentSizeAssert, timesTemplateTypeSize, vectorSize;
if ( templatedParams.find( vectorParams.begin()->first ) == templatedParams.end() )
{
vectorSize = counterName;
}
else
{
templateArgumentSizeAssert = "\n VULKAN_HPP_ASSERT( " + counterName + " % sizeof( " + vectorElementType + " ) == 0 );";
timesTemplateTypeSize = " * sizeof( " + vectorElementType + " )";
vectorSize = counterName + " / sizeof( " + vectorElementType + " )";
}
std::string vectorName = startLowerCase( stripPrefix( commandIt->second.params[vectorParams.begin()->first].name, "p" ) );
return replaceWithMap( definitionTemplate,
{ { "argumentList", argumentList },
{ "argumentTemplates", argumentTemplates },
{ "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
{ "commandName", commandName },
{ "counterName", counterName },
{ "counterType", commandIt->second.params[vectorParams.begin()->second].type.type },
{ "firstCallArguments", firstCallArguments },
{ "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
{ "secondCallArguments", secondCallArguments },
{ "templateArgumentSizeAssert", templateArgumentSizeAssert },
{ "timesTemplateTypeSize", timesTemplateTypeSize },
{ "vectorElementType", vectorElementType },
{ "vectorName", vectorName },
{ "vectorSize", vectorSize },
{ "vkCommand", commandIt->first } } );
}
else
{
std::string const declarationTemplate =
R"(
${argumentTemplates}
VULKAN_HPP_NODISCARD std::vector<${vectorElementType}> ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;
)";
return replaceWithMap( declarationTemplate,
{ { "argumentList", argumentList },
{ "argumentTemplates", argumentTemplates },
{ "commandName", commandName },
{ "vectorElementType", vectorElementType } } );
}
}
std::pair<std::string, std::string> std::pair<std::string, std::string>
VulkanHppGenerator::generateRAIIHandleConstructor( std::pair<std::string, HandleData> const & handle, VulkanHppGenerator::generateRAIIHandleConstructor( std::pair<std::string, HandleData> const & handle,
std::map<std::string, VulkanHppGenerator::CommandData>::const_iterator constructorIt, std::map<std::string, VulkanHppGenerator::CommandData>::const_iterator constructorIt,

8
VulkanHppGenerator.hpp
View File

@ -400,7 +400,8 @@ private:
std::vector<size_t> const & returnParams, std::vector<size_t> const & returnParams,
bool singular, bool singular,
bool enumerating, bool enumerating,
std::vector<std::string> const & dataTypes ) const; std::vector<std::string> const & dataTypes,
bool raii ) const;
bool containsArray( std::string const & type ) const; bool containsArray( std::string const & type ) const;
bool containsFuncPointer( std::string const & type ) const; bool containsFuncPointer( std::string const & type ) const;
bool containsFloatingPoints( std::vector<MemberData> const & members ) const; bool containsFloatingPoints( std::vector<MemberData> const & members ) const;
@ -816,11 +817,6 @@ private:
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
std::vector<size_t> const & returnParamIndices, std::vector<size_t> const & returnParamIndices,
bool definition ) const; bool definition ) const;
std::string generateRAIIHandleCommandVoid2ReturnEnumerateValue( std::map<std::string, CommandData>::const_iterator commandIt,
size_t initialSkipCount,
std::map<size_t, size_t> const & vectorParamIndices,
std::vector<size_t> const & returnParamIndices,
bool definition ) const;
std::pair<std::string, std::string> generateRAIIHandleConstructor( std::pair<std::string, HandleData> const & handle, std::pair<std::string, std::string> generateRAIIHandleConstructor( std::pair<std::string, HandleData> const & handle,
std::map<std::string, CommandData>::const_iterator constructorIt, std::map<std::string, CommandData>::const_iterator constructorIt,
std::string const & enter, std::string const & enter,

219
vulkan/vulkan_raii.hpp
View File

@ -10213,6 +10213,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkImageCreateFlags>( flags ), static_cast<VkImageCreateFlags>( flags ),
reinterpret_cast<VkImageFormatProperties *>( &imageFormatProperties ) ); reinterpret_cast<VkImageFormatProperties *>( &imageFormatProperties ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" );
return imageFormatProperties; return imageFormatProperties;
} }
@ -10228,13 +10229,19 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>
PhysicalDevice::getQueueFamilyProperties() const VULKAN_HPP_NOEXCEPT PhysicalDevice::getQueueFamilyProperties() const VULKAN_HPP_NOEXCEPT
{ {
uint32_t queueFamilyPropertyCount; std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> queueFamilyProperties;
uint32_t queueFamilyPropertyCount;
getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> queueFamilyProperties( queueFamilyPropertyCount ); queueFamilyProperties.resize( queueFamilyPropertyCount );
getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
&queueFamilyPropertyCount, &queueFamilyPropertyCount,
reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) ); reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) );
VULKAN_HPP_ASSERT( queueFamilyPropertyCount == queueFamilyProperties.size() );
VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
{
queueFamilyProperties.resize( queueFamilyPropertyCount );
}
return queueFamilyProperties; return queueFamilyProperties;
} }
@ -10439,6 +10446,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkMemoryMapFlags>( flags ), static_cast<VkMemoryMapFlags>( flags ),
&pData ); &pData );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::mapMemory" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::mapMemory" );
return pData; return pData;
} }
@ -10507,15 +10515,21 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>
Image::getSparseMemoryRequirements() const VULKAN_HPP_NOEXCEPT Image::getSparseMemoryRequirements() const VULKAN_HPP_NOEXCEPT
{ {
uint32_t sparseMemoryRequirementCount; std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> sparseMemoryRequirements;
uint32_t sparseMemoryRequirementCount;
getDispatcher()->vkGetImageSparseMemoryRequirements( getDispatcher()->vkGetImageSparseMemoryRequirements(
static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), &sparseMemoryRequirementCount, nullptr ); static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), &sparseMemoryRequirementCount, nullptr );
std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> sparseMemoryRequirements( sparseMemoryRequirementCount ); sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
getDispatcher()->vkGetImageSparseMemoryRequirements( static_cast<VkDevice>( m_device ), getDispatcher()->vkGetImageSparseMemoryRequirements( static_cast<VkDevice>( m_device ),
static_cast<VkImage>( m_image ), static_cast<VkImage>( m_image ),
&sparseMemoryRequirementCount, &sparseMemoryRequirementCount,
reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) ); reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
VULKAN_HPP_ASSERT( sparseMemoryRequirementCount == sparseMemoryRequirements.size() );
VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
{
sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
}
return sparseMemoryRequirements; return sparseMemoryRequirements;
} }
@ -10526,7 +10540,8 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
VULKAN_HPP_NAMESPACE::ImageTiling tiling ) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_NAMESPACE::ImageTiling tiling ) const VULKAN_HPP_NOEXCEPT
{ {
uint32_t propertyCount; std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> properties;
uint32_t propertyCount;
getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
static_cast<VkFormat>( format ), static_cast<VkFormat>( format ),
static_cast<VkImageType>( type ), static_cast<VkImageType>( type ),
@ -10535,7 +10550,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkImageTiling>( tiling ), static_cast<VkImageTiling>( tiling ),
&propertyCount, &propertyCount,
nullptr ); nullptr );
std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> properties( propertyCount ); properties.resize( propertyCount );
getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
static_cast<VkFormat>( format ), static_cast<VkFormat>( format ),
static_cast<VkImageType>( type ), static_cast<VkImageType>( type ),
@ -10544,7 +10559,12 @@ 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() );
VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
if ( propertyCount < properties.size() )
{
properties.resize( propertyCount );
}
return properties; return properties;
} }
@ -10574,6 +10594,7 @@ namespace VULKAN_HPP_NAMESPACE
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
VULKAN_HPP_NAMESPACE_STRING "::Fence::getStatus", VULKAN_HPP_NAMESPACE_STRING "::Fence::getStatus",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
} }
@ -10585,6 +10606,7 @@ namespace VULKAN_HPP_NAMESPACE
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences", VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } );
return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
} }
@ -10608,6 +10630,7 @@ namespace VULKAN_HPP_NAMESPACE
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
VULKAN_HPP_NAMESPACE_STRING "::Event::getStatus", VULKAN_HPP_NAMESPACE_STRING "::Event::getStatus",
{ VULKAN_HPP_NAMESPACE::Result::eEventSet, VULKAN_HPP_NAMESPACE::Result::eEventReset } ); { VULKAN_HPP_NAMESPACE::Result::eEventSet, VULKAN_HPP_NAMESPACE::Result::eEventReset } );
return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
} }
@ -11347,6 +11370,7 @@ namespace VULKAN_HPP_NAMESPACE
uint32_t apiVersion; uint32_t apiVersion;
VkResult result = getDispatcher()->vkEnumerateInstanceVersion( &apiVersion ); VkResult result = getDispatcher()->vkEnumerateInstanceVersion( &apiVersion );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceVersion" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceVersion" );
return apiVersion; return apiVersion;
} }
@ -11477,15 +11501,21 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
Device::getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT Device::getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
{ {
uint32_t sparseMemoryRequirementCount; std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements;
uint32_t sparseMemoryRequirementCount;
getDispatcher()->vkGetImageSparseMemoryRequirements2( getDispatcher()->vkGetImageSparseMemoryRequirements2(
static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr ); static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr );
std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements( sparseMemoryRequirementCount ); sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
getDispatcher()->vkGetImageSparseMemoryRequirements2( static_cast<VkDevice>( m_device ), getDispatcher()->vkGetImageSparseMemoryRequirements2( static_cast<VkDevice>( m_device ),
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() );
VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
{
sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
}
return sparseMemoryRequirements; return sparseMemoryRequirements;
} }
@ -11560,6 +11590,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ); reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
return imageFormatProperties; return imageFormatProperties;
} }
@ -11583,13 +11614,19 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>
PhysicalDevice::getQueueFamilyProperties2() const VULKAN_HPP_NOEXCEPT PhysicalDevice::getQueueFamilyProperties2() const VULKAN_HPP_NOEXCEPT
{ {
uint32_t queueFamilyPropertyCount; std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties;
uint32_t queueFamilyPropertyCount;
getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount ); queueFamilyProperties.resize( queueFamilyPropertyCount );
getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
&queueFamilyPropertyCount, &queueFamilyPropertyCount,
reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
VULKAN_HPP_ASSERT( queueFamilyPropertyCount == queueFamilyProperties.size() );
VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
{
queueFamilyProperties.resize( queueFamilyPropertyCount );
}
return queueFamilyProperties; return queueFamilyProperties;
} }
@ -11640,17 +11677,23 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
PhysicalDevice::getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const VULKAN_HPP_NOEXCEPT PhysicalDevice::getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const VULKAN_HPP_NOEXCEPT
{ {
uint32_t propertyCount; std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties;
uint32_t propertyCount;
getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
&propertyCount, &propertyCount,
nullptr ); nullptr );
std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties( propertyCount ); properties.resize( propertyCount );
getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
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() );
VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
if ( propertyCount < properties.size() )
{
properties.resize( propertyCount );
}
return properties; return properties;
} }
@ -11819,6 +11862,7 @@ namespace VULKAN_HPP_NAMESPACE
uint64_t value; uint64_t value;
VkResult result = getDispatcher()->vkGetSemaphoreCounterValue( static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ); VkResult result = getDispatcher()->vkGetSemaphoreCounterValue( static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValue" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValue" );
return value; return value;
} }
@ -11830,6 +11874,7 @@ namespace VULKAN_HPP_NAMESPACE
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores", VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } );
return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
} }
@ -12180,15 +12225,21 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
Device::getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT Device::getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
{ {
uint32_t sparseMemoryRequirementCount; std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements;
uint32_t sparseMemoryRequirementCount;
getDispatcher()->vkGetDeviceImageSparseMemoryRequirements( getDispatcher()->vkGetDeviceImageSparseMemoryRequirements(
static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr ); static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr );
std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements( sparseMemoryRequirementCount ); sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
getDispatcher()->vkGetDeviceImageSparseMemoryRequirements( static_cast<VkDevice>( m_device ), getDispatcher()->vkGetDeviceImageSparseMemoryRequirements( static_cast<VkDevice>( m_device ),
reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
&sparseMemoryRequirementCount, &sparseMemoryRequirementCount,
reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
VULKAN_HPP_ASSERT( sparseMemoryRequirementCount == sparseMemoryRequirements.size() );
VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
{
sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
}
return sparseMemoryRequirements; return sparseMemoryRequirements;
} }
@ -12204,6 +12255,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR( VkResult result = getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR(
static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkBool32 *>( &supported ) ); static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkBool32 *>( &supported ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" );
return supported; return supported;
} }
@ -12218,6 +12270,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkSurfaceKHR>( surface ), static_cast<VkSurfaceKHR>( surface ),
reinterpret_cast<VkSurfaceCapabilitiesKHR *>( &surfaceCapabilities ) ); reinterpret_cast<VkSurfaceCapabilitiesKHR *>( &surfaceCapabilities ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" );
return surfaceCapabilities; return surfaceCapabilities;
} }
@ -12354,6 +12407,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Result::eTimeout, VULKAN_HPP_NAMESPACE::Result::eTimeout,
VULKAN_HPP_NAMESPACE::Result::eNotReady, VULKAN_HPP_NAMESPACE::Result::eNotReady,
VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), imageIndex ); return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), imageIndex );
} }
@ -12365,6 +12419,7 @@ namespace VULKAN_HPP_NAMESPACE
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR", VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
} }
@ -12377,6 +12432,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR( VkResult result = getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR(
static_cast<VkDevice>( m_device ), reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( &deviceGroupPresentCapabilities ) ); static_cast<VkDevice>( m_device ), reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( &deviceGroupPresentCapabilities ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" );
return deviceGroupPresentCapabilities; return deviceGroupPresentCapabilities;
} }
@ -12390,6 +12446,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR( VkResult result = getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR(
static_cast<VkDevice>( m_device ), static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ); static_cast<VkDevice>( m_device ), static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" );
return modes; return modes;
} }
@ -12444,6 +12501,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::Result::eTimeout, VULKAN_HPP_NAMESPACE::Result::eTimeout,
VULKAN_HPP_NAMESPACE::Result::eNotReady, VULKAN_HPP_NAMESPACE::Result::eNotReady,
VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), imageIndex ); return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), imageIndex );
} }
@ -12576,6 +12634,7 @@ namespace VULKAN_HPP_NAMESPACE
planeIndex, planeIndex,
reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) ); reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::DisplayModeKHR::getDisplayPlaneCapabilities" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::DisplayModeKHR::getDisplayPlaneCapabilities" );
return capabilities; return capabilities;
} }
@ -12792,6 +12851,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkVideoProfileKHR *>( &videoProfile ), reinterpret_cast<const VkVideoProfileKHR *>( &videoProfile ),
reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ); reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
return capabilities; return capabilities;
} }
@ -13108,6 +13168,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetImageViewAddressNVX( VkResult result = getDispatcher()->vkGetImageViewAddressNVX(
static_cast<VkDevice>( m_device ), static_cast<VkImageView>( m_imageView ), reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) ); static_cast<VkDevice>( m_device ), static_cast<VkImageView>( m_imageView ), reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::ImageView::getAddressNVX" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::ImageView::getAddressNVX" );
return properties; return properties;
} }
@ -13245,6 +13306,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ),
reinterpret_cast<VkExternalImageFormatPropertiesNV *>( &externalImageFormatProperties ) ); reinterpret_cast<VkExternalImageFormatPropertiesNV *>( &externalImageFormatProperties ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" );
return externalImageFormatProperties; return externalImageFormatProperties;
} }
@ -13260,6 +13322,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetMemoryWin32HandleNV( VkResult result = getDispatcher()->vkGetMemoryWin32HandleNV(
static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle ); static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::getMemoryWin32HandleNV" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::getMemoryWin32HandleNV" );
return handle; return handle;
} }
# endif /*VK_USE_PLATFORM_WIN32_KHR*/ # endif /*VK_USE_PLATFORM_WIN32_KHR*/
@ -13358,6 +13421,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ); reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
return imageFormatProperties; return imageFormatProperties;
} }
@ -13383,13 +13447,20 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR && VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR &&
"Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" ); "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
uint32_t queueFamilyPropertyCount;
std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties;
uint32_t queueFamilyPropertyCount;
getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount ); queueFamilyProperties.resize( queueFamilyPropertyCount );
getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
&queueFamilyPropertyCount, &queueFamilyPropertyCount,
reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
VULKAN_HPP_ASSERT( queueFamilyPropertyCount == queueFamilyProperties.size() );
VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
{
queueFamilyProperties.resize( queueFamilyPropertyCount );
}
return queueFamilyProperties; return queueFamilyProperties;
} }
@ -13450,17 +13521,24 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR && VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR &&
"Function <vkGetPhysicalDeviceSparseImageFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" ); "Function <vkGetPhysicalDeviceSparseImageFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
uint32_t propertyCount;
std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties;
uint32_t propertyCount;
getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
&propertyCount, &propertyCount,
nullptr ); nullptr );
std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties( propertyCount ); properties.resize( propertyCount );
getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
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() );
VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
if ( propertyCount < properties.size() )
{
properties.resize( propertyCount );
}
return properties; return properties;
} }
@ -13589,6 +13667,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetMemoryWin32HandleKHR( VkResult result = getDispatcher()->vkGetMemoryWin32HandleKHR(
static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ); static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" );
return handle; return handle;
} }
@ -13605,6 +13684,7 @@ namespace VULKAN_HPP_NAMESPACE
handle, handle,
reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( &memoryWin32HandleProperties ) ); reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( &memoryWin32HandleProperties ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" );
return memoryWin32HandleProperties; return memoryWin32HandleProperties;
} }
# endif /*VK_USE_PLATFORM_WIN32_KHR*/ # endif /*VK_USE_PLATFORM_WIN32_KHR*/
@ -13619,6 +13699,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = VkResult result =
getDispatcher()->vkGetMemoryFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetFdInfoKHR *>( &getFdInfo ), &fd ); getDispatcher()->vkGetMemoryFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetFdInfoKHR *>( &getFdInfo ), &fd );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" );
return fd; return fd;
} }
@ -13634,6 +13715,7 @@ namespace VULKAN_HPP_NAMESPACE
fd, fd,
reinterpret_cast<VkMemoryFdPropertiesKHR *>( &memoryFdProperties ) ); reinterpret_cast<VkMemoryFdPropertiesKHR *>( &memoryFdProperties ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" );
return memoryFdProperties; return memoryFdProperties;
} }
@ -13678,6 +13760,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetSemaphoreWin32HandleKHR( VkResult result = getDispatcher()->vkGetSemaphoreWin32HandleKHR(
static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ); static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" );
return handle; return handle;
} }
# endif /*VK_USE_PLATFORM_WIN32_KHR*/ # endif /*VK_USE_PLATFORM_WIN32_KHR*/
@ -13702,6 +13785,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = VkResult result =
getDispatcher()->vkGetSemaphoreFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( &getFdInfo ), &fd ); getDispatcher()->vkGetSemaphoreFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( &getFdInfo ), &fd );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" );
return fd; return fd;
} }
@ -13843,6 +13927,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkSurfaceKHR>( surface ), static_cast<VkSurfaceKHR>( surface ),
reinterpret_cast<VkSurfaceCapabilities2EXT *>( &surfaceCapabilities ) ); reinterpret_cast<VkSurfaceCapabilities2EXT *>( &surfaceCapabilities ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" );
return surfaceCapabilities; return surfaceCapabilities;
} }
@ -13881,6 +13966,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetSwapchainCounterEXT( VkResult result = getDispatcher()->vkGetSwapchainCounterEXT(
static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue ); static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getCounterEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getCounterEXT" );
return counterValue; return counterValue;
} }
@ -13896,6 +13982,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkSwapchainKHR>( m_swapchain ), static_cast<VkSwapchainKHR>( m_swapchain ),
reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) ); reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getRefreshCycleDurationGOOGLE" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getRefreshCycleDurationGOOGLE" );
return displayTimingProperties; return displayTimingProperties;
} }
@ -14015,6 +14102,7 @@ namespace VULKAN_HPP_NAMESPACE
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getStatus", VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getStatus",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
} }
@ -14057,6 +14145,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetFenceWin32HandleKHR( VkResult result = getDispatcher()->vkGetFenceWin32HandleKHR(
static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ); static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" );
return handle; return handle;
} }
# endif /*VK_USE_PLATFORM_WIN32_KHR*/ # endif /*VK_USE_PLATFORM_WIN32_KHR*/
@ -14079,6 +14168,7 @@ namespace VULKAN_HPP_NAMESPACE
int fd; int fd;
VkResult result = getDispatcher()->vkGetFenceFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetFdInfoKHR *>( &getFdInfo ), &fd ); VkResult result = getDispatcher()->vkGetFenceFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetFdInfoKHR *>( &getFdInfo ), &fd );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" );
return fd; return fd;
} }
@ -14169,6 +14259,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ); reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" );
return surfaceCapabilities; return surfaceCapabilities;
} }
@ -14392,6 +14483,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( &displayPlaneInfo ), reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( &displayPlaneInfo ),
reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( &capabilities ) ); reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( &capabilities ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" );
return capabilities; return capabilities;
} }
@ -14523,6 +14615,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID( VkResult result = getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID(
static_cast<VkDevice>( m_device ), &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ); static_cast<VkDevice>( m_device ), &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
return properties; return properties;
} }
@ -14551,6 +14644,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID( VkResult result = getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID(
static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( &info ), &buffer ); static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( &info ), &buffer );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" );
return buffer; return buffer;
} }
# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
@ -14648,15 +14742,22 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSparseMemoryRequirements2KHR && VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSparseMemoryRequirements2KHR &&
"Function <vkGetImageSparseMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" ); "Function <vkGetImageSparseMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
uint32_t sparseMemoryRequirementCount;
std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements;
uint32_t sparseMemoryRequirementCount;
getDispatcher()->vkGetImageSparseMemoryRequirements2KHR( getDispatcher()->vkGetImageSparseMemoryRequirements2KHR(
static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr ); static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr );
std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements( sparseMemoryRequirementCount ); sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
getDispatcher()->vkGetImageSparseMemoryRequirements2KHR( static_cast<VkDevice>( m_device ), getDispatcher()->vkGetImageSparseMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
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() );
VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
{
sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
}
return sparseMemoryRequirements; return sparseMemoryRequirements;
} }
@ -14740,6 +14841,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, { VULKAN_HPP_NAMESPACE::Result::eSuccess,
VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
} }
@ -14758,6 +14860,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, { VULKAN_HPP_NAMESPACE::Result::eSuccess,
VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
} }
@ -14777,6 +14880,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, { VULKAN_HPP_NAMESPACE::Result::eSuccess,
VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
} }
@ -14796,6 +14900,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, { VULKAN_HPP_NAMESPACE::Result::eSuccess,
VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
} }
@ -14995,6 +15100,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT( VkResult result = getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT(
static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) ); static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Image::getDrmFormatModifierPropertiesEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Image::getDrmFormatModifierPropertiesEXT" );
return properties; return properties;
} }
@ -15410,6 +15516,7 @@ namespace VULKAN_HPP_NAMESPACE
pHostPointer, pHostPointer,
reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( &memoryHostPointerProperties ) ); reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( &memoryHostPointerProperties ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" );
return memoryHostPointerProperties; return memoryHostPointerProperties;
} }
@ -15572,12 +15679,19 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointDataNV && VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointDataNV &&
"Function <vkGetQueueCheckpointDataNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!" ); "Function <vkGetQueueCheckpointDataNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!" );
uint32_t checkpointDataCount;
std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> checkpointData;
uint32_t checkpointDataCount;
getDispatcher()->vkGetQueueCheckpointDataNV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr ); getDispatcher()->vkGetQueueCheckpointDataNV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr );
std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> checkpointData( checkpointDataCount ); checkpointData.resize( checkpointDataCount );
getDispatcher()->vkGetQueueCheckpointDataNV( getDispatcher()->vkGetQueueCheckpointDataNV(
static_cast<VkQueue>( m_queue ), &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) ); static_cast<VkQueue>( m_queue ), &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) );
VULKAN_HPP_ASSERT( checkpointDataCount == checkpointData.size() );
VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
if ( checkpointDataCount < checkpointData.size() )
{
checkpointData.resize( checkpointDataCount );
}
return checkpointData; return checkpointData;
} }
@ -15591,6 +15705,7 @@ namespace VULKAN_HPP_NAMESPACE
uint64_t value; uint64_t value;
VkResult result = getDispatcher()->vkGetSemaphoreCounterValueKHR( static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ); VkResult result = getDispatcher()->vkGetSemaphoreCounterValueKHR( static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValueKHR" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValueKHR" );
return value; return value;
} }
@ -15604,6 +15719,7 @@ namespace VULKAN_HPP_NAMESPACE
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR", VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } );
return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
} }
@ -15692,6 +15808,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetPerformanceParameterINTEL( VkResult result = getDispatcher()->vkGetPerformanceParameterINTEL(
static_cast<VkDevice>( m_device ), static_cast<VkPerformanceParameterTypeINTEL>( parameter ), reinterpret_cast<VkPerformanceValueINTEL *>( &value ) ); static_cast<VkDevice>( m_device ), static_cast<VkPerformanceParameterTypeINTEL>( parameter ), reinterpret_cast<VkPerformanceValueINTEL *>( &value ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" );
return value; return value;
} }
@ -15837,6 +15954,7 @@ namespace VULKAN_HPP_NAMESPACE
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::waitForPresent", VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::waitForPresent",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
} }
@ -15987,6 +16105,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ); reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" );
return modes; return modes;
} }
# endif /*VK_USE_PLATFORM_WIN32_KHR*/ # endif /*VK_USE_PLATFORM_WIN32_KHR*/
@ -16224,6 +16343,7 @@ namespace VULKAN_HPP_NAMESPACE
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
VULKAN_HPP_NAMESPACE_STRING "::DeferredOperationKHR::join", VULKAN_HPP_NAMESPACE_STRING "::DeferredOperationKHR::join",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR, VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR } ); { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR, VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR } );
return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
} }
@ -16598,12 +16718,19 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointData2NV && VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointData2NV &&
"Function <vkGetQueueCheckpointData2NV> needs extension <VK_KHR_synchronization2> enabled!" ); "Function <vkGetQueueCheckpointData2NV> needs extension <VK_KHR_synchronization2> enabled!" );
uint32_t checkpointDataCount;
std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> checkpointData;
uint32_t checkpointDataCount;
getDispatcher()->vkGetQueueCheckpointData2NV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr ); getDispatcher()->vkGetQueueCheckpointData2NV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr );
std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> checkpointData( checkpointDataCount ); checkpointData.resize( checkpointDataCount );
getDispatcher()->vkGetQueueCheckpointData2NV( getDispatcher()->vkGetQueueCheckpointData2NV(
static_cast<VkQueue>( m_queue ), &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) ); static_cast<VkQueue>( m_queue ), &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) );
VULKAN_HPP_ASSERT( checkpointDataCount == checkpointData.size() );
VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
if ( checkpointDataCount < checkpointData.size() )
{
checkpointData.resize( checkpointDataCount );
}
return checkpointData; return checkpointData;
} }
@ -16929,6 +17056,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetMemoryZirconHandleFUCHSIA( VkResult result = getDispatcher()->vkGetMemoryZirconHandleFUCHSIA(
static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle ); static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" );
return zirconHandle; return zirconHandle;
} }
@ -16945,6 +17073,7 @@ namespace VULKAN_HPP_NAMESPACE
zirconHandle, zirconHandle,
reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( &memoryZirconHandleProperties ) ); reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( &memoryZirconHandleProperties ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" );
return memoryZirconHandleProperties; return memoryZirconHandleProperties;
} }
# endif /*VK_USE_PLATFORM_FUCHSIA*/ # endif /*VK_USE_PLATFORM_FUCHSIA*/
@ -16973,6 +17102,7 @@ namespace VULKAN_HPP_NAMESPACE
VkResult result = getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA( VkResult result = getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA(
static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle ); static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" );
return zirconHandle; return zirconHandle;
} }
# endif /*VK_USE_PLATFORM_FUCHSIA*/ # endif /*VK_USE_PLATFORM_FUCHSIA*/
@ -17022,6 +17152,7 @@ namespace VULKAN_HPP_NAMESPACE
static_cast<VkBufferCollectionFUCHSIA>( m_collection ), static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( &properties ) ); reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( &properties ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::getProperties" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::getProperties" );
return properties; return properties;
} }
# endif /*VK_USE_PLATFORM_FUCHSIA*/ # endif /*VK_USE_PLATFORM_FUCHSIA*/
@ -17040,6 +17171,7 @@ namespace VULKAN_HPP_NAMESPACE
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
VULKAN_HPP_NAMESPACE_STRING "::RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI", VULKAN_HPP_NAMESPACE_STRING "::RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI",
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete } ); { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete } );
return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), maxWorkgroupSize ); return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), maxWorkgroupSize );
} }
@ -17076,6 +17208,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( &memoryGetRemoteAddressInfo ), reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( &memoryGetRemoteAddressInfo ),
reinterpret_cast<VkRemoteAddressNV *>( &address ) ); reinterpret_cast<VkRemoteAddressNV *>( &address ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" );
return address; return address;
} }
@ -17092,6 +17225,7 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkPipelineInfoEXT *>( &pipelineInfo ), reinterpret_cast<const VkPipelineInfoEXT *>( &pipelineInfo ),
reinterpret_cast<VkBaseOutStructure *>( &pipelineProperties ) ); reinterpret_cast<VkBaseOutStructure *>( &pipelineProperties ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelinePropertiesEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelinePropertiesEXT" );
return pipelineProperties; return pipelineProperties;
} }
@ -17308,15 +17442,22 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR && VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR &&
"Function <vkGetDeviceImageSparseMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" ); "Function <vkGetDeviceImageSparseMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" );
uint32_t sparseMemoryRequirementCount;
std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements;
uint32_t sparseMemoryRequirementCount;
getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR( getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR(
static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr ); static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr );
std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements( sparseMemoryRequirementCount ); sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR( static_cast<VkDevice>( m_device ), getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
&sparseMemoryRequirementCount, &sparseMemoryRequirementCount,
reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
VULKAN_HPP_ASSERT( sparseMemoryRequirementCount == sparseMemoryRequirements.size() );
VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
{
sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
}
return sparseMemoryRequirements; return sparseMemoryRequirements;
} }