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

Extend support of some special type of functions. (#1567)

Browse Source
This commit is contained in:
Andreas Süßenbach 2023-04-24 18:06:06 +02:00 committed by GitHub
parent f06c4aa1d3
commit 95c622a64f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 112 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
VulkanHppGenerator.cpp
View File

@ -3649,12 +3649,13 @@ std::string VulkanHppGenerator::generateCommandResultMultiSuccessWithErrors3Retu
switch ( vectorParams.size() ) switch ( vectorParams.size() )
{ {
case 1: case 1:
if ( commandData.params[returnParams[0]].type.type == "VkBool32" ) if ( ( commandData.params[returnParams[0]].type.type != "void" ) && !isHandleType( commandData.params[returnParams[0]].type.type ) &&
!isStructureChainAnchor( commandData.params[returnParams[0]].type.type ) )
{ {
if ( commandData.params[returnParams[1]].type.type == "uint32_t" ) if ( ( commandData.params[returnParams[1]].type.type == "size_t" ) || ( commandData.params[returnParams[1]].type.type == "uint32_t" ) )
{ {
if ( ( commandData.params[returnParams[2]].type.type != "void" ) && !isHandleType( commandData.params[returnParams[2]].type.type ) && if ( ( commandData.params[returnParams[2]].type.type == "void" ) ||
!isStructureChainAnchor( commandData.params[returnParams[2]].type.type ) ) ( !isHandleType( commandData.params[returnParams[2]].type.type ) && !isStructureChainAnchor( commandData.params[returnParams[2]].type.type ) ) )
{ {
if ( returnParams[1] == vectorParams.begin()->second.lenParam ) if ( returnParams[1] == vectorParams.begin()->second.lenParam )
{ {
@ -4616,8 +4617,7 @@ std::string VulkanHppGenerator::generateDataDeclarations( CommandData const &
assert( !( flavourFlags & CommandFlavourFlagBits::unique ) ); assert( !( flavourFlags & CommandFlavourFlagBits::unique ) );
return generateDataDeclarations2Returns( commandData, returnParams, vectorParams, flavourFlags, raii, dataTypes, dataType, returnVariable ); return generateDataDeclarations2Returns( commandData, returnParams, vectorParams, flavourFlags, raii, dataTypes, dataType, returnVariable );
case 3: case 3:
assert( templatedParams.empty() && assert( !( flavourFlags & ( CommandFlavourFlagBits::chained | CommandFlavourFlagBits::singular | CommandFlavourFlagBits::unique ) ) );
!( flavourFlags & ( CommandFlavourFlagBits::chained | CommandFlavourFlagBits::singular | CommandFlavourFlagBits::unique ) ) );
return generateDataDeclarations3Returns( commandData, returnParams, vectorParams, flavourFlags, raii, dataTypes ); return generateDataDeclarations3Returns( commandData, returnParams, vectorParams, flavourFlags, raii, dataTypes );
default: assert( false ); return ""; default: assert( false ); return "";
} }
@ -4695,9 +4695,9 @@ std::string VulkanHppGenerator::generateDataDeclarations2Returns( CommandData co
std::string firstDataVariable = startLowerCase( stripPrefix( commandData.params[returnParams[0]].name, "p" ) ); std::string firstDataVariable = startLowerCase( stripPrefix( commandData.params[returnParams[0]].name, "p" ) );
std::string secondDataVariable = startLowerCase( stripPrefix( commandData.params[returnParams[1]].name, "p" ) ); std::string secondDataVariable = startLowerCase( stripPrefix( commandData.params[returnParams[1]].name, "p" ) );
std::string const dataDeclarationTemplate = R"(std::pair<${firstDataType},${secondDataType}> data; std::string const dataDeclarationTemplate = R"(std::pair<${firstDataType},${secondDataType}> data_;
${firstDataType} & ${firstDataVariable} = data.first; ${firstDataType} & ${firstDataVariable} = data_.first;
${secondDataType} & ${secondDataVariable} = data.second;)"; ${secondDataType} & ${secondDataVariable} = data_.second;)";
return replaceWithMap( dataDeclarationTemplate, return replaceWithMap( dataDeclarationTemplate,
{ { "firstDataType", dataTypes[0] }, { { "firstDataType", dataTypes[0] },
@ -4755,9 +4755,9 @@ std::string VulkanHppGenerator::generateDataDeclarations2Returns( CommandData co
{ {
firstDataVariable = stripPluralS( firstDataVariable ); firstDataVariable = stripPluralS( firstDataVariable );
std::string const dataDeclarationTemplate = R"(std::pair<${firstDataType},${secondDataType}> data; std::string const dataDeclarationTemplate = R"(std::pair<${firstDataType},${secondDataType}> data_;
${firstDataType} & ${firstDataVariable} = data.first; ${firstDataType} & ${firstDataVariable} = data_.first;
${secondDataType} & ${secondDataVariable} = data.second;)"; ${secondDataType} & ${secondDataVariable} = data_.second;)";
return replaceWithMap( dataDeclarationTemplate, return replaceWithMap( dataDeclarationTemplate,
{ { "firstDataType", dataTypes[0] }, { { "firstDataType", dataTypes[0] },
@ -4776,9 +4776,9 @@ std::string VulkanHppGenerator::generateDataDeclarations2Returns( CommandData co
std::string vectorSize = startLowerCase( stripPrefix( commandData.params[vectorParams.begin()->first].name, "p" ) ) + ".size()"; std::string vectorSize = startLowerCase( stripPrefix( commandData.params[vectorParams.begin()->first].name, "p" ) ) + ".size()";
std::string const dataDeclarationTemplate = std::string const dataDeclarationTemplate =
R"(std::pair<std::vector<${firstDataType}${allocatorType}>,${secondDataType}> data( std::piecewise_construct, std::forward_as_tuple( ${vectorSize}${allocateInitializer} ), std::forward_as_tuple( 0 ) ); R"(std::pair<std::vector<${firstDataType}${allocatorType}>,${secondDataType}> data_( std::piecewise_construct, std::forward_as_tuple( ${vectorSize}${allocateInitializer} ), std::forward_as_tuple( 0 ) );
std::vector<${firstDataType}${allocatorType}> & ${firstDataVariable} = data.first; std::vector<${firstDataType}${allocatorType}> & ${firstDataVariable} = data_.first;
${secondDataType} & ${secondDataVariable} = data.second;)"; ${secondDataType} & ${secondDataVariable} = data_.second;)";
return replaceWithMap( dataDeclarationTemplate, return replaceWithMap( dataDeclarationTemplate,
{ { "allocateInitializer", allocateInitializer }, { { "allocateInitializer", allocateInitializer },
@ -4817,15 +4817,15 @@ std::string VulkanHppGenerator::generateDataDeclarations3Returns( CommandData co
vectorAllocatorType = startUpperCase( stripPrefix( dataTypes[2], "VULKAN_HPP_NAMESPACE::" ) ) + "Allocator"; vectorAllocatorType = startUpperCase( stripPrefix( dataTypes[2], "VULKAN_HPP_NAMESPACE::" ) ) + "Allocator";
pairConstructor = pairConstructor =
( flavourFlags & CommandFlavourFlagBits::withAllocator ) ( flavourFlags & CommandFlavourFlagBits::withAllocator )
? ( "( std::piecewise_construct, std::forward_as_tuple( false ), std::forward_as_tuple( " + startLowerCase( vectorAllocatorType ) + " ) )" ) ? ( "( std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( " + startLowerCase( vectorAllocatorType ) + " ) )" )
: ""; : "";
vectorAllocatorType = ", " + vectorAllocatorType; vectorAllocatorType = ", " + vectorAllocatorType;
} }
std::string const dataDeclarationsTemplate = std::string const dataDeclarationsTemplate =
R"(std::pair<${valueType},std::vector<${vectorElementType}${vectorAllocatorType}>> data${pairConstructor}; R"(std::pair<${valueType},std::vector<${vectorElementType}${vectorAllocatorType}>> data_${pairConstructor};
${valueType} & ${valueVariable} = data.first; ${valueType} & ${valueVariable} = data_.first;
std::vector<${vectorElementType}${vectorAllocatorType}> & ${vectorVariable} = data.second; std::vector<${vectorElementType}${vectorAllocatorType}> & ${vectorVariable} = data_.second;
${counterType} ${counterVariable};)"; ${counterType} ${counterVariable};)";
return replaceWithMap( dataDeclarationsTemplate, return replaceWithMap( dataDeclarationsTemplate,
@ -4861,9 +4861,9 @@ std::string VulkanHppGenerator::generateDataDeclarations3Returns( CommandData co
} }
std::string const dataDeclarationsTemplate = std::string const dataDeclarationsTemplate =
R"(std::pair<std::vector<${firstVectorElementType}${firstVectorAllocatorType}>, std::vector<${secondVectorElementType}${secondVectorAllocatorType}>> data${pairConstructor}; R"(std::pair<std::vector<${firstVectorElementType}${firstVectorAllocatorType}>, std::vector<${secondVectorElementType}${secondVectorAllocatorType}>> data_${pairConstructor};
std::vector<${firstVectorElementType}${firstVectorAllocatorType}> & ${firstVectorVariable} = data.first; std::vector<${firstVectorElementType}${firstVectorAllocatorType}> & ${firstVectorVariable} = data_.first;
std::vector<${secondVectorElementType}${secondVectorAllocatorType}> & ${secondVectorVariable} = data.second; std::vector<${secondVectorElementType}${secondVectorAllocatorType}> & ${secondVectorVariable} = data_.second;
${counterType} ${counterVariable};)"; ${counterType} ${counterVariable};)";
return replaceWithMap( dataDeclarationsTemplate, return replaceWithMap( dataDeclarationsTemplate,
@ -9124,8 +9124,8 @@ std::string VulkanHppGenerator::generateReturnVariable( CommandData const &
{ {
auto vectorParamIt = vectorParams.find( returnParams[1] ); auto vectorParamIt = vectorParams.find( returnParams[1] );
if ( vectorParamIt == vectorParams.end() ) if ( vectorParamIt == vectorParams.end() )
{ // the return variable is simply named "data", and holds the multi-return value stuff { // the return variable is simply named "data_", and holds the multi-return value stuff
returnVariable = "data"; returnVariable = "data_";
} }
else else
{ {
@ -9142,7 +9142,7 @@ std::string VulkanHppGenerator::generateReturnVariable( CommandData const &
( ( vectorParams.size() == 2 ) && ( vectorParams.begin()->first == returnParams[1] ) && ( ( vectorParams.size() == 2 ) && ( vectorParams.begin()->first == returnParams[1] ) &&
( vectorParams.begin()->second.lenParam == returnParams[0] ) && ( std::next( vectorParams.begin() )->first == returnParams[2] ) && ( vectorParams.begin()->second.lenParam == returnParams[0] ) && ( std::next( vectorParams.begin() )->first == returnParams[2] ) &&
( std::next( vectorParams.begin() )->second.lenParam == returnParams[0] ) ) ); ( std::next( vectorParams.begin() )->second.lenParam == returnParams[0] ) ) );
returnVariable = "data"; returnVariable = "data_";
break; break;
} }
return returnVariable; return returnVariable;

48
vulkan/vulkan_funcs.hpp
View File

@ -12501,9 +12501,9 @@ namespace VULKAN_HPP_NAMESPACE
std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>, std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>> std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>
data; data_;
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data.first; std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data_.first;
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions = data.second; std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions = data_.second;
uint32_t counterCount; uint32_t counterCount;
VkResult result; VkResult result;
do do
@ -12529,7 +12529,7 @@ namespace VULKAN_HPP_NAMESPACE
counters.resize( counterCount ); counters.resize( counterCount );
counterDescriptions.resize( counterCount ); counterDescriptions.resize( counterCount );
} }
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
} }
template <typename PerformanceCounterKHRAllocator, template <typename PerformanceCounterKHRAllocator,
@ -12552,10 +12552,10 @@ namespace VULKAN_HPP_NAMESPACE
std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>, std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>> std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>
data( data_(
std::piecewise_construct, std::forward_as_tuple( performanceCounterKHRAllocator ), std::forward_as_tuple( performanceCounterDescriptionKHRAllocator ) ); std::piecewise_construct, std::forward_as_tuple( performanceCounterKHRAllocator ), std::forward_as_tuple( performanceCounterDescriptionKHRAllocator ) );
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data.first; std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data_.first;
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions = data.second; std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions = data_.second;
uint32_t counterCount; uint32_t counterCount;
VkResult result; VkResult result;
do do
@ -12581,7 +12581,7 @@ namespace VULKAN_HPP_NAMESPACE
counters.resize( counterCount ); counters.resize( counterCount );
counterDescriptions.resize( counterCount ); counterDescriptions.resize( counterCount );
} }
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
} }
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -16068,15 +16068,15 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data( std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
std::vector<uint64_t, Uint64_tAllocator> & timestamps = data.first; std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
uint64_t & maxDeviation = data.second; uint64_t & maxDeviation = data_.second;
VkResult result = d.vkGetCalibratedTimestampsEXT( VkResult result = d.vkGetCalibratedTimestampsEXT(
m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ); m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), timestamps.data(), &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
} }
template <typename Uint64_tAllocator, template <typename Uint64_tAllocator,
@ -16090,15 +16090,15 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data( std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) ); std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) );
std::vector<uint64_t, Uint64_tAllocator> & timestamps = data.first; std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
uint64_t & maxDeviation = data.second; uint64_t & maxDeviation = data_.second;
VkResult result = d.vkGetCalibratedTimestampsEXT( VkResult result = d.vkGetCalibratedTimestampsEXT(
m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ); m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), timestamps.data(), &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
} }
template <typename Dispatch> template <typename Dispatch>
@ -16107,14 +16107,14 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::pair<uint64_t, uint64_t> data; std::pair<uint64_t, uint64_t> data_;
uint64_t & timestamp = data.first; uint64_t & timestamp = data_.first;
uint64_t & maxDeviation = data.second; uint64_t & maxDeviation = data_.second;
VkResult result = VkResult result =
d.vkGetCalibratedTimestampsEXT( m_device, 1, reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( &timestampInfo ), &timestamp, &maxDeviation ); d.vkGetCalibratedTimestampsEXT( m_device, 1, reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( &timestampInfo ), &timestamp, &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
} }
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -19244,9 +19244,9 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT> data; std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT> data_;
VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT & faultCounts = data.first; VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT & faultCounts = data_.first;
VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT & faultInfo = data.second; VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT & faultInfo = data_.second;
VkResult result = VkResult result =
d.vkGetDeviceFaultInfoEXT( m_device, reinterpret_cast<VkDeviceFaultCountsEXT *>( &faultCounts ), reinterpret_cast<VkDeviceFaultInfoEXT *>( &faultInfo ) ); d.vkGetDeviceFaultInfoEXT( m_device, reinterpret_cast<VkDeviceFaultCountsEXT *>( &faultCounts ), reinterpret_cast<VkDeviceFaultInfoEXT *>( &faultInfo ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
@ -19254,7 +19254,7 @@ namespace VULKAN_HPP_NAMESPACE
{ VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete } ); { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete } );
return ResultValue<std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>>( return ResultValue<std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>>(
static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data ); static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
} }
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

32
vulkan/vulkan_raii.hpp
View File

@ -15905,9 +15905,9 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR && VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR &&
"Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> requires <VK_KHR_performance_query>" ); "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> requires <VK_KHR_performance_query>" );
std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>> data; std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>> data_;
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> & counters = data.first; std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> & counters = data_.first;
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR> & counterDescriptions = data.second; std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR> & counterDescriptions = data_.second;
uint32_t counterCount; uint32_t counterCount;
VkResult result; VkResult result;
do do
@ -15934,7 +15934,7 @@ namespace VULKAN_HPP_NAMESPACE
counters.resize( counterCount ); counters.resize( counterCount );
counterDescriptions.resize( counterCount ); counterDescriptions.resize( counterCount );
} }
return data; return data_;
} }
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR(
@ -17399,9 +17399,9 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT && "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps>" ); VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT && "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps>" );
std::pair<std::vector<uint64_t>, uint64_t> data( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); std::pair<std::vector<uint64_t>, uint64_t> data_( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
std::vector<uint64_t> & timestamps = data.first; std::vector<uint64_t> & timestamps = data_.first;
uint64_t & maxDeviation = data.second; uint64_t & maxDeviation = data_.second;
VkResult result = getDispatcher()->vkGetCalibratedTimestampsEXT( static_cast<VkDevice>( m_device ), VkResult result = getDispatcher()->vkGetCalibratedTimestampsEXT( static_cast<VkDevice>( m_device ),
timestampInfos.size(), timestampInfos.size(),
reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ),
@ -17409,7 +17409,7 @@ namespace VULKAN_HPP_NAMESPACE
&maxDeviation ); &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
return data; return data_;
} }
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint64_t, uint64_t> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint64_t, uint64_t>
@ -17417,14 +17417,14 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT && "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps>" ); VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT && "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps>" );
std::pair<uint64_t, uint64_t> data; std::pair<uint64_t, uint64_t> data_;
uint64_t & timestamp = data.first; uint64_t & timestamp = data_.first;
uint64_t & maxDeviation = data.second; uint64_t & maxDeviation = data_.second;
VkResult result = getDispatcher()->vkGetCalibratedTimestampsEXT( VkResult result = getDispatcher()->vkGetCalibratedTimestampsEXT(
static_cast<VkDevice>( m_device ), 1, reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( &timestampInfo ), &timestamp, &maxDeviation ); static_cast<VkDevice>( m_device ), 1, reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( &timestampInfo ), &timestamp, &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" );
return data; return data_;
} }
//=== VK_NV_mesh_shader === //=== VK_NV_mesh_shader ===
@ -18857,16 +18857,16 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceFaultInfoEXT && "Function <vkGetDeviceFaultInfoEXT> requires <VK_EXT_device_fault>" ); VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceFaultInfoEXT && "Function <vkGetDeviceFaultInfoEXT> requires <VK_EXT_device_fault>" );
std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT> data; std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT> data_;
VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT & faultCounts = data.first; VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT & faultCounts = data_.first;
VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT & faultInfo = data.second; VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT & faultInfo = data_.second;
VkResult result = getDispatcher()->vkGetDeviceFaultInfoEXT( VkResult result = getDispatcher()->vkGetDeviceFaultInfoEXT(
static_cast<VkDevice>( m_device ), reinterpret_cast<VkDeviceFaultCountsEXT *>( &faultCounts ), reinterpret_cast<VkDeviceFaultInfoEXT *>( &faultInfo ) ); static_cast<VkDevice>( m_device ), reinterpret_cast<VkDeviceFaultCountsEXT *>( &faultCounts ), reinterpret_cast<VkDeviceFaultInfoEXT *>( &faultInfo ) );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultInfoEXT", VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultInfoEXT",
{ 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 ), data ); return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
} }
# if defined( VK_USE_PLATFORM_WIN32_KHR ) # if defined( VK_USE_PLATFORM_WIN32_KHR )

58
vulkan/vulkansc_funcs.hpp
View File

@ -6605,9 +6605,9 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::pair<VULKAN_HPP_NAMESPACE::Bool32, std::vector<VULKAN_HPP_NAMESPACE::FaultData, FaultDataAllocator>> data; std::pair<VULKAN_HPP_NAMESPACE::Bool32, std::vector<VULKAN_HPP_NAMESPACE::FaultData, FaultDataAllocator>> data_;
VULKAN_HPP_NAMESPACE::Bool32 & unrecordedFaults = data.first; VULKAN_HPP_NAMESPACE::Bool32 & unrecordedFaults = data_.first;
std::vector<VULKAN_HPP_NAMESPACE::FaultData, FaultDataAllocator> & faults = data.second; std::vector<VULKAN_HPP_NAMESPACE::FaultData, FaultDataAllocator> & faults = data_.second;
uint32_t faultCount; uint32_t faultCount;
VkResult result; VkResult result;
do do
@ -6626,7 +6626,7 @@ namespace VULKAN_HPP_NAMESPACE
} while ( result == VK_INCOMPLETE ); } while ( result == VK_INCOMPLETE );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultData" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultData" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
} }
template <typename FaultDataAllocator, template <typename FaultDataAllocator,
@ -6639,10 +6639,10 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::pair<VULKAN_HPP_NAMESPACE::Bool32, std::vector<VULKAN_HPP_NAMESPACE::FaultData, FaultDataAllocator>> data( std::pair<VULKAN_HPP_NAMESPACE::Bool32, std::vector<VULKAN_HPP_NAMESPACE::FaultData, FaultDataAllocator>> data_(
std::piecewise_construct, std::forward_as_tuple( false ), std::forward_as_tuple( faultDataAllocator ) ); std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( faultDataAllocator ) );
VULKAN_HPP_NAMESPACE::Bool32 & unrecordedFaults = data.first; VULKAN_HPP_NAMESPACE::Bool32 & unrecordedFaults = data_.first;
std::vector<VULKAN_HPP_NAMESPACE::FaultData, FaultDataAllocator> & faults = data.second; std::vector<VULKAN_HPP_NAMESPACE::FaultData, FaultDataAllocator> & faults = data_.second;
uint32_t faultCount; uint32_t faultCount;
VkResult result; VkResult result;
do do
@ -6661,7 +6661,7 @@ namespace VULKAN_HPP_NAMESPACE
} while ( result == VK_INCOMPLETE ); } while ( result == VK_INCOMPLETE );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultData" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultData" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
} }
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -8358,9 +8358,9 @@ namespace VULKAN_HPP_NAMESPACE
std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>, std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>> std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>
data; data_;
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data.first; std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data_.first;
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions = data.second; std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions = data_.second;
uint32_t counterCount; uint32_t counterCount;
VkResult result; VkResult result;
do do
@ -8386,7 +8386,7 @@ namespace VULKAN_HPP_NAMESPACE
counters.resize( counterCount ); counters.resize( counterCount );
counterDescriptions.resize( counterCount ); counterDescriptions.resize( counterCount );
} }
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
} }
template <typename PerformanceCounterKHRAllocator, template <typename PerformanceCounterKHRAllocator,
@ -8409,10 +8409,10 @@ namespace VULKAN_HPP_NAMESPACE
std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>, std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>> std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>
data( data_(
std::piecewise_construct, std::forward_as_tuple( performanceCounterKHRAllocator ), std::forward_as_tuple( performanceCounterDescriptionKHRAllocator ) ); std::piecewise_construct, std::forward_as_tuple( performanceCounterKHRAllocator ), std::forward_as_tuple( performanceCounterDescriptionKHRAllocator ) );
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data.first; std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR, PerformanceCounterKHRAllocator> & counters = data_.first;
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions = data.second; std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator> & counterDescriptions = data_.second;
uint32_t counterCount; uint32_t counterCount;
VkResult result; VkResult result;
do do
@ -8438,7 +8438,7 @@ namespace VULKAN_HPP_NAMESPACE
counters.resize( counterCount ); counters.resize( counterCount );
counterDescriptions.resize( counterCount ); counterDescriptions.resize( counterCount );
} }
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
} }
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -9442,15 +9442,15 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data( std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
std::vector<uint64_t, Uint64_tAllocator> & timestamps = data.first; std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
uint64_t & maxDeviation = data.second; uint64_t & maxDeviation = data_.second;
VkResult result = d.vkGetCalibratedTimestampsEXT( VkResult result = d.vkGetCalibratedTimestampsEXT(
m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ); m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), timestamps.data(), &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
} }
template <typename Uint64_tAllocator, template <typename Uint64_tAllocator,
@ -9464,15 +9464,15 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data( std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t> data_(
std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) ); std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) );
std::vector<uint64_t, Uint64_tAllocator> & timestamps = data.first; std::vector<uint64_t, Uint64_tAllocator> & timestamps = data_.first;
uint64_t & maxDeviation = data.second; uint64_t & maxDeviation = data_.second;
VkResult result = d.vkGetCalibratedTimestampsEXT( VkResult result = d.vkGetCalibratedTimestampsEXT(
m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), timestamps.data(), &maxDeviation ); m_device, timestampInfos.size(), reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), timestamps.data(), &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
} }
template <typename Dispatch> template <typename Dispatch>
@ -9481,14 +9481,14 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::pair<uint64_t, uint64_t> data; std::pair<uint64_t, uint64_t> data_;
uint64_t & timestamp = data.first; uint64_t & timestamp = data_.first;
uint64_t & maxDeviation = data.second; uint64_t & maxDeviation = data_.second;
VkResult result = VkResult result =
d.vkGetCalibratedTimestampsEXT( m_device, 1, reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( &timestampInfo ), &timestamp, &maxDeviation ); d.vkGetCalibratedTimestampsEXT( m_device, 1, reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( &timestampInfo ), &timestamp, &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data ); return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
} }
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

32
vulkan/vulkansc_raii.hpp
View File

@ -8764,9 +8764,9 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( getDispatcher()->vkGetFaultData && "Function <vkGetFaultData> requires <VKSC_VERSION_1_0>" ); VULKAN_HPP_ASSERT( getDispatcher()->vkGetFaultData && "Function <vkGetFaultData> requires <VKSC_VERSION_1_0>" );
std::pair<VULKAN_HPP_NAMESPACE::Bool32, std::vector<VULKAN_HPP_NAMESPACE::FaultData>> data; std::pair<VULKAN_HPP_NAMESPACE::Bool32, std::vector<VULKAN_HPP_NAMESPACE::FaultData>> data_;
VULKAN_HPP_NAMESPACE::Bool32 & unrecordedFaults = data.first; VULKAN_HPP_NAMESPACE::Bool32 & unrecordedFaults = data_.first;
std::vector<VULKAN_HPP_NAMESPACE::FaultData> & faults = data.second; std::vector<VULKAN_HPP_NAMESPACE::FaultData> & faults = data_.second;
uint32_t faultCount; uint32_t faultCount;
VkResult result; VkResult result;
do do
@ -8788,7 +8788,7 @@ namespace VULKAN_HPP_NAMESPACE
} while ( result == VK_INCOMPLETE ); } while ( result == VK_INCOMPLETE );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultData" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultData" );
return data; return data_;
} }
//=== VK_KHR_surface === //=== VK_KHR_surface ===
@ -9365,9 +9365,9 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR && VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR &&
"Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> requires <VK_KHR_performance_query>" ); "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> requires <VK_KHR_performance_query>" );
std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>> data; std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>> data_;
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> & counters = data.first; std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> & counters = data_.first;
std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR> & counterDescriptions = data.second; std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR> & counterDescriptions = data_.second;
uint32_t counterCount; uint32_t counterCount;
VkResult result; VkResult result;
do do
@ -9394,7 +9394,7 @@ namespace VULKAN_HPP_NAMESPACE
counters.resize( counterCount ); counters.resize( counterCount );
counterDescriptions.resize( counterCount ); counterDescriptions.resize( counterCount );
} }
return data; return data_;
} }
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR(
@ -9818,9 +9818,9 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT && "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps>" ); VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT && "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps>" );
std::pair<std::vector<uint64_t>, uint64_t> data( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); std::pair<std::vector<uint64_t>, uint64_t> data_( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
std::vector<uint64_t> & timestamps = data.first; std::vector<uint64_t> & timestamps = data_.first;
uint64_t & maxDeviation = data.second; uint64_t & maxDeviation = data_.second;
VkResult result = getDispatcher()->vkGetCalibratedTimestampsEXT( static_cast<VkDevice>( m_device ), VkResult result = getDispatcher()->vkGetCalibratedTimestampsEXT( static_cast<VkDevice>( m_device ),
timestampInfos.size(), timestampInfos.size(),
reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ),
@ -9828,7 +9828,7 @@ namespace VULKAN_HPP_NAMESPACE
&maxDeviation ); &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
return data; return data_;
} }
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint64_t, uint64_t> VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint64_t, uint64_t>
@ -9836,14 +9836,14 @@ namespace VULKAN_HPP_NAMESPACE
{ {
VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT && "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps>" ); VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT && "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps>" );
std::pair<uint64_t, uint64_t> data; std::pair<uint64_t, uint64_t> data_;
uint64_t & timestamp = data.first; uint64_t & timestamp = data_.first;
uint64_t & maxDeviation = data.second; uint64_t & maxDeviation = data_.second;
VkResult result = getDispatcher()->vkGetCalibratedTimestampsEXT( VkResult result = getDispatcher()->vkGetCalibratedTimestampsEXT(
static_cast<VkDevice>( m_device ), 1, reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( &timestampInfo ), &timestamp, &maxDeviation ); static_cast<VkDevice>( m_device ), 1, reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( &timestampInfo ), &timestamp, &maxDeviation );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" ); resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" );
return data; return data_;
} }
//=== VK_KHR_fragment_shading_rate === //=== VK_KHR_fragment_shading_rate ===