From d691f5f0e82c5cfb73abe64c3f6cd7a7833d42be Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Tue, 7 Jun 2022 18:02:52 +0200 Subject: [PATCH] Combine two types of commands into one generation function --- VulkanHppGenerator.cpp | 136 ++++++++++++-------------------------- VulkanHppGenerator.hpp | 9 +-- vulkan/vulkan_enums.hpp | 52 +++++++-------- vulkan/vulkan_raii.hpp | 33 +++++++++ vulkan/vulkan_structs.hpp | 18 ++--- 5 files changed, 112 insertions(+), 136 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index d2a2456..f601c01 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -2607,11 +2607,13 @@ std::string VulkanHppGenerator::generateArgumentTemplates( std::vector const & returnParams, std::map const & vectorParams, std::set const & templatedParams, + bool chained, bool complete ) const { std::string argumentTemplates; if ( !templatedParams.empty() ) { + assert( !chained ); for ( auto t : templatedParams ) { assert( beginsWith( params[t].name, "p" ) ); @@ -2623,10 +2625,14 @@ std::string VulkanHppGenerator::generateArgumentTemplates( std::vector"; - } + } + else if ( chained ) + { + argumentTemplates = ( returnParams.size() == 1 ) ? "typename X, typename Y, typename... Z, " : "typename StructureChain, "; + } + if ( !argumentTemplates.empty() && complete ) + { + argumentTemplates = "template <" + stripPostfix( argumentTemplates, ", " ) + ">"; } return argumentTemplates; } @@ -3259,12 +3265,6 @@ std::string VulkanHppGenerator::generateCallSequence( std::string const & } } -std::string VulkanHppGenerator::generateChainTemplates( std::vector const & returnParams, bool chained ) const -{ - assert( !chained || ( returnParams.size() == 1 ) || ( returnParams.size() == 2 ) ); - return chained ? ( ( returnParams.size() == 1 ) ? "typename X, typename Y, typename... Z, " : "typename StructureChain, " ) : ""; -} - std::string VulkanHppGenerator::generateCommand( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const { std::string str; @@ -3430,8 +3430,7 @@ std::string VulkanHppGenerator::generateCommandEnhanced( std::string const & std::vector dataTypes = determineDataTypes( commandData.params, vectorParams, returnParams, templatedParams ); std::string dataType = combineDataTypes( vectorParams, returnParams, singular, enumerating, dataTypes ); - std::string argumentTemplates = generateArgumentTemplates( commandData.params, returnParams, vectorParams, templatedParams, false ); - std::string chainTemplates = generateChainTemplates( returnParams, chained ); + std::string argumentTemplates = generateArgumentTemplates( commandData.params, returnParams, vectorParams, templatedParams, chained, false ); auto [allocatorTemplates, uniqueHandleAllocatorTemplates] = generateAllocatorTemplates( returnParams, dataTypes, vectorParams, definition, singular, unique, chained ); std::string typenameCheck = generateTypenameCheck( returnParams, vectorParams, definition, dataTypes, singular, withAllocator, unique, chained ); @@ -3478,7 +3477,7 @@ std::string VulkanHppGenerator::generateCommandEnhanced( std::string const & false ); std::string const functionTemplate = - R"( template <${argumentTemplates}${chainTemplates}${allocatorTemplates}typename Dispatch${uniqueHandleAllocatorTemplates}${typenameCheck}> + R"( template <${argumentTemplates}${allocatorTemplates}typename Dispatch${uniqueHandleAllocatorTemplates}${typenameCheck}> ${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}${classSeparator}${commandName}( ${argumentList} )${const}${noexcept} { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); @@ -3496,7 +3495,6 @@ ${vectorSizeCheck} { "argumentList", argumentList }, { "argumentTemplates", argumentTemplates }, { "callSequence", callSequence }, - { "chainTemplates", chainTemplates }, { "className", className }, { "classSeparator", classSeparator }, { "commandName", commandName }, @@ -3516,14 +3514,13 @@ ${vectorSizeCheck} else { std::string const functionTemplate = - R"( template <${argumentTemplates}${chainTemplates}${allocatorTemplates}typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${uniqueHandleAllocatorTemplates}${typenameCheck}> + R"( template <${argumentTemplates}${allocatorTemplates}typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${uniqueHandleAllocatorTemplates}${typenameCheck}> ${nodiscard}${returnType} ${commandName}( ${argumentList} )${const}${noexcept};)"; return replaceWithMap( functionTemplate, { { "allocatorTemplates", allocatorTemplates }, { "argumentList", argumentList }, { "argumentTemplates", argumentTemplates }, - { "chainTemplates", chainTemplates }, { "commandName", commandName }, { "const", commandData.handle.empty() ? "" : " const" }, { "nodiscard", nodiscard }, @@ -6117,7 +6114,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandEnhanced( std::map const & returnParams, std::map const & vectorParams, - bool definition ) const + bool definition, + bool chained ) const { std::set skippedParams = determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, returnParams, false ); std::set singularParams = false ? determineSingularParams( returnParams[0], vectorParams ) : std::set(); @@ -6127,7 +6125,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandEnhanced( std::map dataTypes = determineDataTypes( commandIt->second.params, vectorParams, returnParams, templatedParams ); std::string dataType = combineDataTypes( vectorParams, returnParams, false, enumerating, dataTypes ); - std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, {}, vectorParams, templatedParams, true ); + std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, returnParams, vectorParams, templatedParams, chained, true ); std::string argumentList = generateArgumentListEnhanced( commandIt->second.params, returnParams, vectorParams, skippedParams, {}, templatedParams, definition, false, false, false ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags, false, false ); @@ -6138,7 +6136,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandEnhanced( std::map>> vectorSizeCheck = needsVectorSizeCheck( commandIt->second.params, vectorParams, returnParams, singularParams ); std::string noexceptString = ( vectorSizeCheck.first || !commandIt->second.errorCodes.empty() ) ? "" : " VULKAN_HPP_NOEXCEPT"; - std::string returnType = generateReturnType( commandIt->second, returnParams, false, false, true, dataType ); + std::string returnType = generateReturnType( commandIt->second, returnParams, false, chained, true, dataType ); if ( definition ) { @@ -6159,9 +6157,9 @@ ${vectorSizeCheck} std::string callSequence = generateCallSequence( commandIt->first, commandIt->second, returnParams, vectorParams, initialSkipCount, singularParams, templatedParams, false, true ); std::string className = stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ); - std::string returnVariable = generateReturnVariable( commandIt->second, returnParams, vectorParams, false, false ); + std::string returnVariable = generateReturnVariable( commandIt->second, returnParams, vectorParams, chained, false ); std::string dataDeclarations = generateDataDeclarations( - commandIt->second, returnParams, vectorParams, templatedParams, false, false, false, false, dataTypes, dataType, returnType, returnVariable ); + commandIt->second, returnParams, vectorParams, templatedParams, false, false, chained, false, dataTypes, dataType, returnType, returnVariable ); std::string resultCheck = generateResultCheck( commandIt->second, className, "::", commandName, enumerating ); std::string returnStatement = generateReturnStatement( commandIt->first, commandIt->second, @@ -6324,7 +6322,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessNoErr switch ( returnParams.size() ) { case 0: - return generateRAIIHandleCommandEnhanced( commandIt, initialSkipCount, returnParams, determineVectorParams( commandIt->second.params ), definition ); + return generateRAIIHandleCommandEnhanced( + commandIt, initialSkipCount, returnParams, determineVectorParams( commandIt->second.params ), definition, false ); case 2: return generateRAIIHandleCommandResultMultiSuccessNoErrors2Return( commandIt, initialSkipCount, definition, returnParams ); } return ""; @@ -6477,7 +6476,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE std::set templatedParams = determineVoidPointerParams( commandIt->second.params ); std::string argumentList = generateArgumentListEnhanced( commandIt->second.params, {}, vectorParams, skippedParams, {}, templatedParams, definition, false, false, false ); - std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, {}, vectorParams, templatedParams, true ); + std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, {}, vectorParams, templatedParams, false, true ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags, false, false ); if ( definition ) @@ -6656,7 +6655,7 @@ std::string assert( templatedParams.size() == 1 ); std::string argumentList = generateArgumentListEnhanced( commandIt->second.params, returnParams, vectorParams, skippedParams, singularParams, templatedParams, definition, false, false, false ); - std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, returnParams, vectorParams, templatedParams, true ); + std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, returnParams, vectorParams, templatedParams, false, true ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags, true, false ); std::string dataType = stripPrefix( commandIt->second.params[*templatedParams.begin()].name, "p" ) + "Type"; @@ -6718,7 +6717,7 @@ std::string std::string argumentList = generateArgumentListEnhanced( commandIt->second.params, returnParams, vectorParams, skippedParams, {}, templatedParams, definition, false, false, false ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags, false, false ); - std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, returnParams, vectorParams, templatedParams, true ); + std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, returnParams, vectorParams, templatedParams, false, true ); std::string dataType = stripPrefix( commandIt->second.params[*templatedParams.begin()].name, "p" ) + "Type"; if ( definition ) @@ -7197,7 +7196,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessNoEr std::vector returnParams = determineReturnParams( commandIt->second.params ); if ( returnParams.empty() ) { - return generateRAIIHandleCommandEnhanced( commandIt, initialSkipCount, returnParams, determineVectorParams( commandIt->second.params ), definition ); + return generateRAIIHandleCommandEnhanced( commandIt, initialSkipCount, returnParams, determineVectorParams( commandIt->second.params ), definition, false ); } return ""; } @@ -7210,7 +7209,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith switch ( returnParams.size() ) { case 0: - return generateRAIIHandleCommandEnhanced( commandIt, initialSkipCount, returnParams, determineVectorParams( commandIt->second.params ), definition ); + return generateRAIIHandleCommandEnhanced( + commandIt, initialSkipCount, returnParams, determineVectorParams( commandIt->second.params ), definition, false ); break; case 1: return generateRAIIHandleCommandResultSingleSuccessWithErrors1Return( commandIt, initialSkipCount, definition, returnParams[0] ); break; case 2: return generateRAIIHandleCommandResultSingleSuccessWithErrors2Return( commandIt, initialSkipCount, definition, returnParams ); break; @@ -7580,7 +7580,7 @@ std::string std::string argumentList = generateArgumentListEnhanced( commandIt->second.params, { returnParam }, vectorParams, skippedParams, singularParams, { returnParam }, definition, false, false, false ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags, true, false ); - std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, { returnParam }, vectorParams, { returnParam }, true ); + std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, { returnParam }, vectorParams, { returnParam }, false, true ); std::string dataType = stripPrefix( commandIt->second.params[returnParam].name, "p" ) + "Type"; if ( definition ) @@ -7642,7 +7642,7 @@ std::string std::set skippedParams = determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, { returnParam }, false ); std::string argumentList = generateArgumentListEnhanced( commandIt->second.params, { returnParam }, vectorParams, skippedParams, {}, { returnParam }, definition, false, false, false ); - std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, { returnParam }, vectorParams, { returnParam }, true ); + std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, { returnParam }, vectorParams, { returnParam }, false, true ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags, false, false ); std::string dataType = stripPrefix( commandIt->second.params[returnParam].name, "p" ) + "Type"; @@ -7882,7 +7882,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandValue( std::map vectorParams = determineVectorParams( commandIt->second.params ); if ( vectorParams.empty() ) { - return generateRAIIHandleCommandEnhanced( commandIt, initialSkipCount, returnParams, vectorParams, definition ); + return generateRAIIHandleCommandEnhanced( commandIt, initialSkipCount, returnParams, vectorParams, definition, false ); } } return ""; @@ -7897,7 +7897,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid( std::map vectorParams = determineVectorParams( commandIt->second.params ); switch ( returnParams.size() ) { - case 0: str = generateRAIIHandleCommandEnhanced( commandIt, initialSkipCount, returnParams, vectorParams, definition ); break; + case 0: str = generateRAIIHandleCommandEnhanced( commandIt, initialSkipCount, returnParams, vectorParams, definition, false ); break; case 1: if ( commandIt->second.params[returnParams[0]].type.postfix == "**" ) { @@ -7906,7 +7906,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid( std::mapsecond.params[returnParams[0]].type.type ) ) { - str += generateRAIIHandleCommandVoid1ReturnChain( commandIt, initialSkipCount, vectorParams, returnParams[0], definition ); + str += generateRAIIHandleCommandEnhanced( commandIt, initialSkipCount, returnParams, vectorParams, definition, true ); } } else @@ -7971,61 +7971,6 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid( std::map::const_iterator commandIt, - size_t initialSkipCount, - std::map const & vectorParams, - size_t returnParam, - bool definition ) const -{ - std::set skippedParams = determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParams, { returnParam }, false ); - std::string argumentList = - generateArgumentListEnhanced( commandIt->second.params, { returnParam }, vectorParams, skippedParams, {}, {}, definition, false, false, false ); - std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags, false, false ); - - if ( definition ) - { - std::string const definitionTemplate = - R"( - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT - {${functionPointerCheck} - StructureChain structureChain; - ${returnType} & ${returnVariable} = structureChain.template get<${returnType}>(); - getDispatcher()->${vkCommand}( ${callArguments} ); - return structureChain; - } -)"; - - std::string callArguments = generateCallArgumentsEnhanced( commandIt->second, initialSkipCount, false, {}, {}, true ); - std::string returnType = stripPostfix( commandIt->second.params[returnParam].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ); - std::string returnVariable = startLowerCase( stripPrefix( commandIt->second.params[returnParam].name, "p" ) ); - - return replaceWithMap( definitionTemplate, - { { "argumentList", argumentList }, - { "callArguments", callArguments }, - { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) }, - { "commandName", commandName }, - { "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) }, - { "returnVariable", returnVariable }, - { "returnType", returnType }, - { "vkCommand", commandIt->first } } ); - } - else - { - std::string const declarationTemplate = - R"( - template - VULKAN_HPP_NODISCARD StructureChain ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT; -)"; - - return replaceWithMap( declarationTemplate, - { - { "argumentList", argumentList }, - { "commandName", commandName }, - } ); - } -} - std::string VulkanHppGenerator::generateRAIIHandleCommandVoid1ReturnVector( std::map::const_iterator commandIt, size_t initialSkipCount, std::map const & vectorParams, @@ -8036,7 +7981,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid1ReturnVector( std: std::set templatedParams = determineVoidPointerParams( commandIt->second.params ); std::string argumentList = generateArgumentListEnhanced( commandIt->second.params, { returnParam }, vectorParams, skippedParams, {}, templatedParams, definition, false, false, false ); - std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, { returnParam }, vectorParams, templatedParams, true ); + std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, { returnParam }, 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() ) ? trimEnd( stripPostfix( commandIt->second.params[vectorParams.begin()->first].type.compose( "VULKAN_HPP_NAMESPACE" ), "*" ) ) @@ -8098,7 +8043,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid1ReturnVoidVectorSi std::string argumentList = generateArgumentListEnhanced( commandIt->second.params, { returnParam }, vectorParams, skippedParams, singularParams, { returnParam }, definition, false, false, false ); std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags, true, false ); - std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, { returnParam }, vectorParams, { returnParam }, true ); + std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, { returnParam }, vectorParams, { returnParam }, false, true ); std::string dataType = stripPrefix( commandIt->second.params[returnParam].name, "p" ) + "Type"; if ( definition ) @@ -8226,7 +8171,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid2ReturnEnumerateVal std::set 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, true ); + 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" ), "*" ) @@ -9726,9 +9671,9 @@ std::string VulkanHppGenerator::generateReturnType( } std::string returnType; - if ( ( 1 < commandData.successCodes.size() ) && returnParams.empty() ) + if ( ( 1 < commandData.successCodes.size() ) && returnParams.empty() && !chained ) { - assert( ( commandData.returnType == "VkResult" ) && !chained && !unique ); + assert( ( commandData.returnType == "VkResult" ) && !unique ); returnType = "VULKAN_HPP_NAMESPACE::Result"; } else if ( ( commandData.returnType != "VkResult" ) && ( commandData.returnType != "void" ) ) @@ -9744,7 +9689,8 @@ std::string VulkanHppGenerator::generateReturnType( } } else if ( ( commandData.returnType == "void" ) || - ( ( commandData.returnType == "VkResult" ) && ( commandData.successCodes.size() == 1 ) && ( commandData.errorCodes.empty() || raii ) ) ) + ( ( commandData.returnType == "VkResult" ) && ( commandData.successCodes.size() == 1 ) && ( commandData.errorCodes.empty() || raii ) ) || + ( chained && raii ) ) { assert( !unique ); assert( ( commandData.returnType != "void" ) || ( returnParams.size() <= 2 ) ); diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index d6fc0f3..14aff6e 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -450,6 +450,7 @@ private: std::vector const & returnParams, std::map const & vectorParams, std::set const & templatedParams, + bool chained, bool complete ) const; std::string generateBitmask( std::map::const_iterator bitmaskIt ) const; std::string generateBitmasks( std::vector const & requireData, std::set & listedBitmasks, std::string const & title ) const; @@ -678,7 +679,8 @@ private: size_t initialSkipCount, std::vector const & returnParams, std::map const & vectorParamIndices, - bool definition ) const; + bool definition, + bool chained ) const; std::string generateRAIIHandleCommandFactory( std::map::const_iterator commandIt, size_t initialSkipCount, std::vector const & returnParams, @@ -812,11 +814,6 @@ private: bool definition ) const; std::string generateRAIIHandleCommandValue( std::map::const_iterator commandIt, size_t initialSkipCount, bool definition ) const; std::string generateRAIIHandleCommandVoid( std::map::const_iterator commandIt, size_t initialSkipCount, bool definition ) const; - std::string generateRAIIHandleCommandVoid1ReturnChain( std::map::const_iterator commandIt, - size_t initialSkipCount, - std::map const & vectorParamIndices, - size_t returnParam, - bool definition ) const; std::string generateRAIIHandleCommandVoid1ReturnVector( std::map::const_iterator commandIt, size_t initialSkipCount, std::map const & vectorParamIndices, diff --git a/vulkan/vulkan_enums.hpp b/vulkan/vulkan_enums.hpp index 631f710..a48df11 100644 --- a/vulkan/vulkan_enums.hpp +++ b/vulkan/vulkan_enums.hpp @@ -8523,12 +8523,12 @@ namespace VULKAN_HPP_NAMESPACE VkFlags( FormatFeatureFlagBits::eDisjoint ) | VkFlags( FormatFeatureFlagBits::eCositedChromaSamples ) | VkFlags( FormatFeatureFlagBits::eSampledImageFilterMinmax ) | VkFlags( FormatFeatureFlagBits::eSampledImageFilterCubicIMG ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( FormatFeatureFlagBits::eVideoDecodeOutputKHR ) | VkFlags( FormatFeatureFlagBits::eVideoDecodeDpbKHR ) + | VkFlags( FormatFeatureFlagBits::eVideoDecodeOutputKHR ) | VkFlags( FormatFeatureFlagBits::eVideoDecodeDpbKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags( FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR ) | VkFlags( FormatFeatureFlagBits::eFragmentDensityMapEXT ) | + | VkFlags( FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR ) | VkFlags( FormatFeatureFlagBits::eFragmentDensityMapEXT ) | VkFlags( FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( FormatFeatureFlagBits::eVideoEncodeInputKHR ) | VkFlags( FormatFeatureFlagBits::eVideoEncodeDpbKHR ) + | VkFlags( FormatFeatureFlagBits::eVideoEncodeInputKHR ) | VkFlags( FormatFeatureFlagBits::eVideoEncodeDpbKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ }; }; @@ -8723,15 +8723,15 @@ namespace VULKAN_HPP_NAMESPACE VkFlags( ImageUsageFlagBits::eDepthStencilAttachment ) | VkFlags( ImageUsageFlagBits::eTransientAttachment ) | VkFlags( ImageUsageFlagBits::eInputAttachment ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( ImageUsageFlagBits::eVideoDecodeDstKHR ) | VkFlags( ImageUsageFlagBits::eVideoDecodeSrcKHR ) | + | VkFlags( ImageUsageFlagBits::eVideoDecodeDstKHR ) | VkFlags( ImageUsageFlagBits::eVideoDecodeSrcKHR ) | VkFlags( ImageUsageFlagBits::eVideoDecodeDpbKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags( ImageUsageFlagBits::eFragmentDensityMapEXT ) | VkFlags( ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR ) + | VkFlags( ImageUsageFlagBits::eFragmentDensityMapEXT ) | VkFlags( ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( ImageUsageFlagBits::eVideoEncodeDstKHR ) | VkFlags( ImageUsageFlagBits::eVideoEncodeSrcKHR ) | + | VkFlags( ImageUsageFlagBits::eVideoEncodeDstKHR ) | VkFlags( ImageUsageFlagBits::eVideoEncodeSrcKHR ) | VkFlags( ImageUsageFlagBits::eVideoEncodeDpbKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags( ImageUsageFlagBits::eInvocationMaskHUAWEI ) + | VkFlags( ImageUsageFlagBits::eInvocationMaskHUAWEI ) }; }; @@ -8964,7 +8964,7 @@ namespace VULKAN_HPP_NAMESPACE allFlags = VkFlags( QueueFlagBits::eGraphics ) | VkFlags( QueueFlagBits::eCompute ) | VkFlags( QueueFlagBits::eTransfer ) | VkFlags( QueueFlagBits::eSparseBinding ) | VkFlags( QueueFlagBits::eProtected ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( QueueFlagBits::eVideoDecodeKHR ) | VkFlags( QueueFlagBits::eVideoEncodeKHR ) + | VkFlags( QueueFlagBits::eVideoDecodeKHR ) | VkFlags( QueueFlagBits::eVideoEncodeKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ }; }; @@ -9574,7 +9574,7 @@ namespace VULKAN_HPP_NAMESPACE allFlags = VkFlags( QueryResultFlagBits::e64 ) | VkFlags( QueryResultFlagBits::eWait ) | VkFlags( QueryResultFlagBits::eWithAvailability ) | VkFlags( QueryResultFlagBits::ePartial ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( QueryResultFlagBits::eWithStatusKHR ) + | VkFlags( QueryResultFlagBits::eWithStatusKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ }; }; @@ -9687,13 +9687,13 @@ namespace VULKAN_HPP_NAMESPACE VkFlags( BufferUsageFlagBits::eIndexBuffer ) | VkFlags( BufferUsageFlagBits::eVertexBuffer ) | VkFlags( BufferUsageFlagBits::eIndirectBuffer ) | VkFlags( BufferUsageFlagBits::eShaderDeviceAddress ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( BufferUsageFlagBits::eVideoDecodeSrcKHR ) | VkFlags( BufferUsageFlagBits::eVideoDecodeDstKHR ) + | VkFlags( BufferUsageFlagBits::eVideoDecodeSrcKHR ) | VkFlags( BufferUsageFlagBits::eVideoDecodeDstKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags( BufferUsageFlagBits::eTransformFeedbackBufferEXT ) | VkFlags( BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT ) | + | VkFlags( BufferUsageFlagBits::eTransformFeedbackBufferEXT ) | VkFlags( BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT ) | VkFlags( BufferUsageFlagBits::eConditionalRenderingEXT ) | VkFlags( BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR ) | VkFlags( BufferUsageFlagBits::eAccelerationStructureStorageKHR ) | VkFlags( BufferUsageFlagBits::eShaderBindingTableKHR ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( BufferUsageFlagBits::eVideoEncodeDstKHR ) | VkFlags( BufferUsageFlagBits::eVideoEncodeSrcKHR ) + | VkFlags( BufferUsageFlagBits::eVideoEncodeDstKHR ) | VkFlags( BufferUsageFlagBits::eVideoEncodeSrcKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ }; }; @@ -11364,13 +11364,13 @@ namespace VULKAN_HPP_NAMESPACE VkFlags( ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eD3D12Heap ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eD3D12Resource ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eDmaBufEXT ) #if defined( VK_USE_PLATFORM_ANDROID_KHR ) - | VkFlags( ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID ) + | VkFlags( ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID ) #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - | VkFlags( ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT ) + | VkFlags( ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT ) | VkFlags( ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT ) #if defined( VK_USE_PLATFORM_FUCHSIA ) - | VkFlags( ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA ) + | VkFlags( ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA ) #endif /*VK_USE_PLATFORM_FUCHSIA*/ - | VkFlags( ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV ) + | VkFlags( ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV ) }; }; @@ -11698,7 +11698,7 @@ namespace VULKAN_HPP_NAMESPACE VkFlags( ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt ) | VkFlags( ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence ) | VkFlags( ExternalSemaphoreHandleTypeFlagBits::eSyncFd ) #if defined( VK_USE_PLATFORM_FUCHSIA ) - | VkFlags( ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA ) + | VkFlags( ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA ) #endif /*VK_USE_PLATFORM_FUCHSIA*/ }; }; @@ -12096,9 +12096,9 @@ namespace VULKAN_HPP_NAMESPACE VkFlags64( PipelineStageFlagBits2::eClear ) | VkFlags64( PipelineStageFlagBits2::eIndexInput ) | VkFlags64( PipelineStageFlagBits2::eVertexAttributeInput ) | VkFlags64( PipelineStageFlagBits2::ePreRasterizationShaders ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags64( PipelineStageFlagBits2::eVideoDecodeKHR ) | VkFlags64( PipelineStageFlagBits2::eVideoEncodeKHR ) + | VkFlags64( PipelineStageFlagBits2::eVideoDecodeKHR ) | VkFlags64( PipelineStageFlagBits2::eVideoEncodeKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags64( PipelineStageFlagBits2::eTransformFeedbackEXT ) | VkFlags64( PipelineStageFlagBits2::eConditionalRenderingEXT ) | + | VkFlags64( PipelineStageFlagBits2::eTransformFeedbackEXT ) | VkFlags64( PipelineStageFlagBits2::eConditionalRenderingEXT ) | VkFlags64( PipelineStageFlagBits2::eCommandPreprocessNV ) | VkFlags64( PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR ) | VkFlags64( PipelineStageFlagBits2::eAccelerationStructureBuildKHR ) | VkFlags64( PipelineStageFlagBits2::eRayTracingShaderKHR ) | VkFlags64( PipelineStageFlagBits2::eFragmentDensityProcessEXT ) | VkFlags64( PipelineStageFlagBits2::eTaskShaderNV ) | @@ -12234,10 +12234,10 @@ namespace VULKAN_HPP_NAMESPACE VkFlags64( AccessFlagBits2::eShaderSampledRead ) | VkFlags64( AccessFlagBits2::eShaderStorageRead ) | VkFlags64( AccessFlagBits2::eShaderStorageWrite ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags64( AccessFlagBits2::eVideoDecodeReadKHR ) | VkFlags64( AccessFlagBits2::eVideoDecodeWriteKHR ) | + | VkFlags64( AccessFlagBits2::eVideoDecodeReadKHR ) | VkFlags64( AccessFlagBits2::eVideoDecodeWriteKHR ) | VkFlags64( AccessFlagBits2::eVideoEncodeReadKHR ) | VkFlags64( AccessFlagBits2::eVideoEncodeWriteKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags64( AccessFlagBits2::eTransformFeedbackWriteEXT ) | VkFlags64( AccessFlagBits2::eTransformFeedbackCounterReadEXT ) | + | VkFlags64( AccessFlagBits2::eTransformFeedbackWriteEXT ) | VkFlags64( AccessFlagBits2::eTransformFeedbackCounterReadEXT ) | VkFlags64( AccessFlagBits2::eTransformFeedbackCounterWriteEXT ) | VkFlags64( AccessFlagBits2::eConditionalRenderingReadEXT ) | VkFlags64( AccessFlagBits2::eCommandPreprocessReadNV ) | VkFlags64( AccessFlagBits2::eCommandPreprocessWriteNV ) | VkFlags64( AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR ) | VkFlags64( AccessFlagBits2::eAccelerationStructureReadKHR ) | @@ -12474,14 +12474,14 @@ namespace VULKAN_HPP_NAMESPACE VkFlags64( FormatFeatureFlagBits2::eStorageReadWithoutFormat ) | VkFlags64( FormatFeatureFlagBits2::eStorageWriteWithoutFormat ) | VkFlags64( FormatFeatureFlagBits2::eSampledImageDepthComparison ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags64( FormatFeatureFlagBits2::eVideoDecodeOutputKHR ) | VkFlags64( FormatFeatureFlagBits2::eVideoDecodeDpbKHR ) + | VkFlags64( FormatFeatureFlagBits2::eVideoDecodeOutputKHR ) | VkFlags64( FormatFeatureFlagBits2::eVideoDecodeDpbKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags64( FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR ) | VkFlags64( FormatFeatureFlagBits2::eFragmentDensityMapEXT ) | + | VkFlags64( FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR ) | VkFlags64( FormatFeatureFlagBits2::eFragmentDensityMapEXT ) | VkFlags64( FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags64( FormatFeatureFlagBits2::eVideoEncodeInputKHR ) | VkFlags64( FormatFeatureFlagBits2::eVideoEncodeDpbKHR ) + | VkFlags64( FormatFeatureFlagBits2::eVideoEncodeInputKHR ) | VkFlags64( FormatFeatureFlagBits2::eVideoEncodeDpbKHR ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | VkFlags64( FormatFeatureFlagBits2::eLinearColorAttachmentNV ) + | VkFlags64( FormatFeatureFlagBits2::eLinearColorAttachmentNV ) }; }; @@ -13005,7 +13005,7 @@ namespace VULKAN_HPP_NAMESPACE { allFlags = VkFlags( VideoCodecOperationFlagBitsKHR::eInvalid ) # if defined( VK_ENABLE_BETA_EXTENSIONS ) - | VkFlags( VideoCodecOperationFlagBitsKHR::eEncodeH264EXT ) | VkFlags( VideoCodecOperationFlagBitsKHR::eEncodeH265EXT ) | + | VkFlags( VideoCodecOperationFlagBitsKHR::eEncodeH264EXT ) | VkFlags( VideoCodecOperationFlagBitsKHR::eEncodeH265EXT ) | VkFlags( VideoCodecOperationFlagBitsKHR::eDecodeH264EXT ) | VkFlags( VideoCodecOperationFlagBitsKHR::eDecodeH265EXT ) # endif /*VK_ENABLE_BETA_EXTENSIONS*/ }; diff --git a/vulkan/vulkan_raii.hpp b/vulkan/vulkan_raii.hpp index 00f8fd0..994c971 100644 --- a/vulkan/vulkan_raii.hpp +++ b/vulkan/vulkan_raii.hpp @@ -11440,6 +11440,7 @@ namespace VULKAN_HPP_NAMESPACE getDispatcher()->vkGetImageMemoryRequirements2( static_cast( m_device ), reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } @@ -11463,6 +11464,7 @@ namespace VULKAN_HPP_NAMESPACE getDispatcher()->vkGetBufferMemoryRequirements2( static_cast( m_device ), reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } @@ -11497,6 +11499,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = structureChain.template get(); getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast( m_physicalDevice ), reinterpret_cast( &features ) ); + return structureChain; } @@ -11516,6 +11519,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = structureChain.template get(); getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast( m_physicalDevice ), reinterpret_cast( &properties ) ); + return structureChain; } @@ -11537,6 +11541,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = structureChain.template get(); getDispatcher()->vkGetPhysicalDeviceFormatProperties2( static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( &formatProperties ) ); + return structureChain; } @@ -11625,6 +11630,7 @@ namespace VULKAN_HPP_NAMESPACE structureChain.template get(); getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( static_cast( m_physicalDevice ), reinterpret_cast( &memoryProperties ) ); + return structureChain; } @@ -11734,6 +11740,7 @@ namespace VULKAN_HPP_NAMESPACE getDispatcher()->vkGetDescriptorSetLayoutSupport( static_cast( m_device ), reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); + return structureChain; } @@ -12144,6 +12151,7 @@ namespace VULKAN_HPP_NAMESPACE getDispatcher()->vkGetDeviceBufferMemoryRequirements( static_cast( m_device ), reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } @@ -12167,6 +12175,7 @@ namespace VULKAN_HPP_NAMESPACE getDispatcher()->vkGetDeviceImageMemoryRequirements( static_cast( m_device ), reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } @@ -13299,10 +13308,12 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2KHR && "Function needs extension enabled!" ); + StructureChain structureChain; VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = structureChain.template get(); getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast( m_physicalDevice ), reinterpret_cast( &features ) ); + return structureChain; } @@ -13323,10 +13334,12 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties2KHR && "Function needs extension enabled!" ); + StructureChain structureChain; VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = structureChain.template get(); getDispatcher()->vkGetPhysicalDeviceProperties2KHR( static_cast( m_physicalDevice ), reinterpret_cast( &properties ) ); + return structureChain; } @@ -13349,10 +13362,12 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR && "Function needs extension enabled!" ); + StructureChain structureChain; VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = structureChain.template get(); getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR( static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( &formatProperties ) ); + return structureChain; } @@ -13447,11 +13462,13 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR && "Function needs extension enabled!" ); + StructureChain structureChain; VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties = structureChain.template get(); getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( static_cast( m_physicalDevice ), reinterpret_cast( &memoryProperties ) ); + return structureChain; } @@ -14651,11 +14668,13 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements2KHR && "Function needs extension enabled!" ); + StructureChain structureChain; VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get(); getDispatcher()->vkGetImageMemoryRequirements2KHR( static_cast( m_device ), reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } @@ -14679,11 +14698,13 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements2KHR && "Function needs extension enabled!" ); + StructureChain structureChain; VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get(); getDispatcher()->vkGetBufferMemoryRequirements2KHR( static_cast( m_device ), reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } @@ -15165,11 +15186,13 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV && "Function needs extension enabled!" ); + StructureChain structureChain; VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR & memoryRequirements = structureChain.template get(); getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( static_cast( m_device ), reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } @@ -15390,11 +15413,13 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSupportKHR && "Function needs extension enabled!" ); + StructureChain structureChain; VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = structureChain.template get(); getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( static_cast( m_device ), reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); + return structureChain; } @@ -16424,11 +16449,13 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV && "Function needs extension enabled!" ); + StructureChain structureChain; VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get(); getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( static_cast( m_device ), reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } @@ -16726,12 +16753,14 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSubresourceLayout2EXT && "Function needs extension enabled!" ); + StructureChain structureChain; VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT & layout = structureChain.template get(); getDispatcher()->vkGetImageSubresourceLayout2EXT( static_cast( m_device ), static_cast( m_image ), reinterpret_cast( &subresource ), reinterpret_cast( &layout ) ); + return structureChain; } @@ -17307,11 +17336,13 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR && "Function needs extension enabled!" ); + StructureChain structureChain; VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get(); getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( static_cast( m_device ), reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } @@ -17335,11 +17366,13 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR && "Function needs extension enabled!" ); + StructureChain structureChain; VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get(); getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( static_cast( m_device ), reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return structureChain; } diff --git a/vulkan/vulkan_structs.hpp b/vulkan/vulkan_structs.hpp index 7245bce..8679b7d 100644 --- a/vulkan/vulkan_structs.hpp +++ b/vulkan/vulkan_structs.hpp @@ -2611,10 +2611,10 @@ namespace VULKAN_HPP_NAMESPACE public: VULKAN_HPP_NAMESPACE::TransformMatrixKHR transform = {}; - uint32_t instanceCustomIndex : 24; - uint32_t mask : 8; + uint32_t instanceCustomIndex : 24; + uint32_t mask : 8; uint32_t instanceShaderBindingTableRecordOffset : 24; - VkGeometryInstanceFlagsKHR flags : 8; + VkGeometryInstanceFlagsKHR flags : 8; uint64_t accelerationStructureReference = {}; }; VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR ) == sizeof( VkAccelerationStructureInstanceKHR ), @@ -2763,10 +2763,10 @@ namespace VULKAN_HPP_NAMESPACE public: VULKAN_HPP_NAMESPACE::TransformMatrixKHR transformT0 = {}; VULKAN_HPP_NAMESPACE::TransformMatrixKHR transformT1 = {}; - uint32_t instanceCustomIndex : 24; - uint32_t mask : 8; + uint32_t instanceCustomIndex : 24; + uint32_t mask : 8; uint32_t instanceShaderBindingTableRecordOffset : 24; - VkGeometryInstanceFlagsKHR flags : 8; + VkGeometryInstanceFlagsKHR flags : 8; uint64_t accelerationStructureReference = {}; }; VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV ) == @@ -3380,10 +3380,10 @@ namespace VULKAN_HPP_NAMESPACE public: VULKAN_HPP_NAMESPACE::SRTDataNV transformT0 = {}; VULKAN_HPP_NAMESPACE::SRTDataNV transformT1 = {}; - uint32_t instanceCustomIndex : 24; - uint32_t mask : 8; + uint32_t instanceCustomIndex : 24; + uint32_t mask : 8; uint32_t instanceShaderBindingTableRecordOffset : 24; - VkGeometryInstanceFlagsKHR flags : 8; + VkGeometryInstanceFlagsKHR flags : 8; uint64_t accelerationStructureReference = {}; }; VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV ) == sizeof( VkAccelerationStructureSRTMotionInstanceNV ),