From 6fca13eaba455a46af9adaa76c16588f623d499d Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Thu, 31 Mar 2022 17:52:32 +0200 Subject: [PATCH] Add support of commands returning void and getting a vector of data. --- VulkanHppGenerator.cpp | 154 ++++++++++++++++++++++++++++++++++++++++- VulkanHppGenerator.hpp | 12 ++++ 2 files changed, 164 insertions(+), 2 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index a4aacbc..3bc8ad2 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -5010,7 +5010,16 @@ std::string VulkanHppGenerator::generateCommandVoid1Return( generateCommandSingle( name, commandData, initialSkipCount, definition, {}, { returnParam }, false, false, false ) ); break; case 1: - if ( returnParam != vectorParams.begin()->first ) + if ( returnParam == vectorParams.begin()->first ) + { + // you get a vector of stuff, with the size being one of the parameters + return generateCommandSetStandardEnhancedWithAllocator( + definition, + generateCommandStandard( name, commandData, initialSkipCount, definition ), + generateCommandVoidGetVector( name, commandData, initialSkipCount, definition, vectorParams, returnParam, false ), + generateCommandVoidGetVector( name, commandData, initialSkipCount, definition, vectorParams, returnParam, true ) ); + } + else { if ( !isHandleType( commandData.params[vectorParams.begin()->first].type.type ) && !isStructureChainAnchor( commandData.params[vectorParams.begin()->first].type.type ) && @@ -5231,6 +5240,78 @@ std::string VulkanHppGenerator::generateCommandVoidEnumerateChained( std::string } } +std::string VulkanHppGenerator::generateCommandVoidGetVector( std::string const & name, + CommandData const & commandData, + size_t initialSkipCount, + bool definition, + std::map const & vectorParams, + size_t returnParam, + bool withAllocator ) const +{ + assert( commandData.returnType == "void" ); + + std::set skippedParams = determineSkippedParams( commandData.params, initialSkipCount, vectorParams, { returnParam }, false ); + std::set templatedParams = determineVoidPointerParams( commandData.params ); + std::string argumentList = generateArgumentListEnhanced( commandData.params, skippedParams, {}, templatedParams, definition, withAllocator, false, true ); + std::string commandName = generateCommandName( name, commandData.params, initialSkipCount, m_tags ); + std::string nodiscard = generateNoDiscard( true, 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() ); + std::string dataType = commandData.params[returnParam].type.type; + std::string returnType = generateReturnType( commandData, { returnParam }, vectorParams, false, false, false, dataType ); + + if ( definition ) + { + std::string const functionTemplate = + R"( template + ${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}${classSeparator}${commandName}( ${argumentList} ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + std::vector<${dataType},${dataTypeAllocator}> ${dataName}( ${dataSize}${vectorAllocator} ) ); + Result result = static_cast( d.${vkCommand}( ${callArguments} ) ); + return createResultValue( result, ${dataName}, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} ); + })"; + + std::string typenameCheck = + withAllocator ? ( ", typename B, typename std::enable_if::value, int>::type " ) : ""; + + return replaceWithMap( functionTemplate, + { { "argumentList", argumentList }, + { "callArguments", generateCallArgumentsEnhanced( commandData, initialSkipCount, false, {}, {}, false ) }, + { "className", initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, + { "classSeparator", commandData.handle.empty() ? "" : "::" }, + { "commandName", commandName }, + { "dataName", startLowerCase( stripPrefix( commandData.params[returnParam].name, "p" ) ) }, + { "dataSize", commandData.params[returnParam].len }, + { "dataType", dataType }, + { "dataTypeAllocator", startUpperCase( dataType ) + "Allocator" }, + { "nodiscard", nodiscard }, + { "returnType", returnType }, + { "successCodeList", generateSuccessCodeList( commandData.successCodes ) }, + { "typenameCheck", typenameCheck }, + { "vectorAllocator", withAllocator ? ( ", " + startLowerCase( dataType ) + "Allocator" ) : "" }, + { "vkCommand", name } } ); + } + else + { + std::string const functionTemplate = + R"( template , typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${typenameCheck}> + ${nodiscard}${returnType} ${commandName}( ${argumentList} ) const;)"; + + std::string typenameCheck = withAllocator + ? ( ", typename B = " + startUpperCase( dataType ) + + "Allocator, typename std::enable_if::value, int>::type = 0" ) + : ""; + + return replaceWithMap( functionTemplate, + { { "argumentList", argumentList }, + { "commandName", commandName }, + { "dataType", dataType }, + { "dataTypeAllocator", startUpperCase( dataType ) + "Allocator" }, + { "nodiscard", nodiscard }, + { "returnType", returnType }, + { "typenameCheck", typenameCheck } } ); + } +} + std::string VulkanHppGenerator::generateConstexprString( std::string const & structName ) const { // structs with a VkBaseInStructure and VkBaseOutStructure can't be a constexpr! @@ -8442,6 +8523,11 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid( std::mapsecond.params[returnParams[0]].type.type ) ); + } } break; case 2: @@ -8633,6 +8719,64 @@ ${vectorSizeCheck} } } +std::string VulkanHppGenerator::generateRAIIHandleCommandVoid1ReturnVector( 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::set templatedParams = determineVoidPointerParams( commandIt->second.params ); + std::string argumentList = generateArgumentListEnhanced( commandIt->second.params, skippedParams, {}, templatedParams, definition, false, false, false ); + std::string argumentTemplates = generateArgumentTemplates( commandIt->second.params, templatedParams, true ); + std::string commandName = generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ); + std::string vectorElementType = ( templatedParams.find( vectorParams.begin()->first ) == templatedParams.end() ) + ? trimEnd( 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 + {${functionPointerCheck} + std::vector<${vectorElementType}> ${vectorName}( ${vectorSize} ); + getDispatcher()->${vkCommand}( ${callArguments} ); + return ${vectorName}; + } +)"; + + std::string callArguments = generateCallArgumentsEnhanced( commandIt->second, initialSkipCount, false, {}, templatedParams, true ); + std::string vectorName = startLowerCase( stripPrefix( commandIt->second.params[vectorParams.begin()->first].name, "p" ) ); + std::string vectorSize = startLowerCase( stripPrefix( commandIt->second.params[vectorParams.begin()->second].name, "p" ) ); + + return replaceWithMap( definitionTemplate, + { { "argumentList", argumentList }, + { "argumentTemplates", argumentTemplates }, + { "callArguments", callArguments }, + { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) }, + { "commandName", commandName }, + { "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) }, + { "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; +)"; + + return replaceWithMap( declarationTemplate, + { { "argumentList", argumentList }, + { "argumentTemplates", argumentTemplates }, + { "commandName", commandName }, + { "vectorElementType", vectorElementType } } ); + } +} + std::string VulkanHppGenerator::generateRAIIHandleCommandVoid2ReturnEnumerateChain( std::map::const_iterator commandIt, size_t initialSkipCount, std::map const & vectorParams, @@ -10184,10 +10328,16 @@ std::string VulkanHppGenerator::generateReturnType( CommandData const & returnType = commandData.returnType; } } - else + else if ( vectorParams.find( returnParams[0] ) == vectorParams.end() ) { returnType = dataType; } + else + { + assert( !singular && !unique ); + assert( !beginsWith( dataType, "Vk" ) ); + returnType = "std::vector<" + dataType + ", " + startUpperCase( dataType ) + "Allocator>"; + } return returnType; } diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index ff980cf..691cd76 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -644,6 +644,13 @@ private: std::pair const & vectorParamIndex, std::vector const & returnParamIndices, bool withAllocators ) const; + std::string generateCommandVoidGetVector( std::string const & name, + CommandData const & commandData, + size_t initialSkipCount, + bool definition, + std::map const & vectorParamIndices, + size_t returnParam, + bool withAllocator ) const; std::string generateConstexprString( std::string const & structName ) const; std::string generateDataDeclarations( CommandData const & commandData, std::vector const & returnParams, @@ -862,6 +869,11 @@ private: 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, + size_t returnParam, + bool definition ) const; std::string generateRAIIHandleCommandVoid2ReturnEnumerateChain( std::map::const_iterator commandIt, size_t initialSkipCount, std::map const & vectorParamIndices,