From 4d21e2b210a247e69930f7252d1f3a6c7e56dbe2 Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Tue, 22 Sep 2020 18:20:08 +0200 Subject: [PATCH] refactor command generation of two-vector getting functions returning void --- VulkanHppGenerator.cpp | 380 ++++++++++++++++++++++++++++++----------- VulkanHppGenerator.hpp | 25 ++- vulkan/vulkan.hpp | 15 +- 3 files changed, 308 insertions(+), 112 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index f5da1c4..acc55a1 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -1293,17 +1293,27 @@ void VulkanHppGenerator::appendCommand( std::string & str, { // two vector parameters auto firstVectorParam = vectorParamIndices.begin(); - auto secondVectorParam = firstVectorParam++; + auto secondVectorParam = std::next( firstVectorParam ); std::vector const & params = commandData.params; - if ( ( firstVectorParam->second == secondVectorParam->second ) && - params[firstVectorParam->first].type.isNonConstPointer() && - params[secondVectorParam->first].type.isNonConstPointer() && - params[firstVectorParam->second].type.isNonConstPointer() ) + if ( ( firstVectorParam->second != INVALID_INDEX ) && ( firstVectorParam->second == secondVectorParam->second ) ) { - // both vectors are non-const pointer (that is, return parameters), and share the same size parameter, which in - // turn is a non-const pointer - appendCommandEnumerateTwoVectors( str, name, commandData, vectorParamIndices, definition ); - appendedFunction = true; + // the two vectors use the very same size parameter + if ( params[firstVectorParam->first].type.isNonConstPointer() && + params[secondVectorParam->first].type.isNonConstPointer() && + params[firstVectorParam->second].type.isNonConstPointer() ) + { + // both vectors, as well as the size parameter are non-const pointer that is output parameters + appendCommandEnumerateTwoVectors( str, name, commandData, vectorParamIndices, definition ); + appendedFunction = true; + } + else if ( params[firstVectorParam->first].type.isConstPointer() && + params[secondVectorParam->first].type.isConstPointer() && + params[firstVectorParam->second].type.isValue() && ( commandData.returnType == "void" ) ) + { + // size is given by value and the vectors are const pointers, that is input parameters; function returns void + appendCommandTwoVectorsVoid( str, name, commandData, vectorParamIndices, definition ); + appendedFunction = true; + } } } break; @@ -1628,8 +1638,7 @@ ${enter}${commandStandard}${newlineOnDefinition} ${commandEnhanced}${newlineOnDefinition} ${commandEnhancedSingular} #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -${leave} -)"; +${leave})"; std::string enter, leave; std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions ); @@ -1658,8 +1667,7 @@ ${enter}${commandStandard}${newlineOnDefinition} #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE ${commandEnhanced} #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -${leave} -)"; +${leave})"; std::string enter, leave; std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions ); @@ -1683,8 +1691,7 @@ ${enter}${commandStandard}${newlineOnDefinition} #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE ${commandEnhanced} #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -${leave} -)"; +${leave})"; std::string enter, leave; std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions ); @@ -1717,6 +1724,36 @@ ${commandStandard} } ) ); } +void VulkanHppGenerator::appendCommandTwoVectorsVoid( std::string & str, + std::string const & name, + CommandData const & commandData, + std::map const & vectorParamIndices, + bool definition ) const +{ + assert( commandData.returnType == "void" ); + assert( vectorParamIndices.size() == 2 ); + + std::string enter, leave; + std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions ); + + const std::string functionTemplate = R"( +${enter}${commandStandard}${newlineOnDefinition} +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE +${commandEnhanced} +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +${leave})"; + + str += + replaceWithMap( functionTemplate, + std::map( + { { "commandEnhanced", + constructCommandTwoVectorsVoid( name, commandData, vectorParamIndices, definition, false ) }, + { "commandStandard", constructCommandStandard( name, commandData, definition ) }, + { "enter", enter }, + { "leave", leave }, + { "newlineOnDefinition", definition ? "\n" : "" } } ) ); +} + void VulkanHppGenerator::appendDispatchLoaderDynamic( std::string & str ) { str += R"( @@ -3693,7 +3730,15 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector const & " + startLowerCase( stripPrefix( params[i].name, "p" ) ); + } + else if ( params[i].optional ) { assert( params[i].type.isConstPointer() ); argumentList += "Optional " + @@ -3748,13 +3793,47 @@ std::string VulkanHppGenerator::constructArgumentListStandard( std::vector const & params, - std::map const & vectorParamIndices, - bool vectorAsNullptr, - bool enhanced, - bool singular ) const +std::string VulkanHppGenerator::constructCallArgument( ParamData const & param, bool enhanced ) const { - size_t countIndex = vectorParamIndices.empty() ? ~0 : vectorParamIndices.begin()->second; + std::string argument = param.name; + if ( beginsWith( param.type.type, "Vk" ) ) + { + if ( param.type.isValue() ) + { + argument = "static_cast<" + param.type.type + ">( " + argument + " )"; + } + else + { + assert( !param.type.postfix.empty() ); + if ( enhanced ) + { + argument = "&" + startLowerCase( stripPrefix( argument, "p" ) ); + } + argument = "reinterpret_cast<" + ( param.type.prefix.empty() ? "" : param.type.prefix ) + " " + param.type.type + + " " + param.type.postfix + ">( " + argument + " )"; + } + } + return argument; +} + +std::string VulkanHppGenerator::constructCallArguments( std::vector const & params, bool enhanced ) const +{ + std::string arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) ); + for ( size_t i = 1; i < params.size(); i++ ) + { + arguments += ", " + constructCallArgument( params[i], enhanced ); + } + return arguments; +} + +std::string + VulkanHppGenerator::constructCallArgumentsEnumerateVectors( std::vector const & params, + std::map const & vectorParamIndices, + bool vectorAsNullptr ) const +{ + assert( vectorParamIndices.size() == 2 ); + + size_t countIndex = vectorParamIndices.begin()->second; assert( ( vectorParamIndices.size() != 2 ) || ( std::next( vectorParamIndices.begin() )->second == countIndex ) ); std::string arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) ); @@ -3763,67 +3842,87 @@ std::string VulkanHppGenerator::constructCallArguments( std::vector c arguments += ", "; if ( i == countIndex ) { - if ( singular ) + assert( !params[i].type.isValue() ); + arguments += "&" + startLowerCase( stripPrefix( params[i].name, "p" ) ); + } + else if ( vectorParamIndices.find( i ) != vectorParamIndices.end() ) + { + if ( vectorAsNullptr ) { - arguments += "sizeof( T )"; - } - else if ( params[i].type.isValue() ) - { - arguments += params[i].name; + arguments += "nullptr"; } else { - arguments += "&" + startLowerCase( stripPrefix( params[i].name, "p" ) ); + arguments += "reinterpret_cast<" + params[i].type.type + " *>( enumeratedData." + + ( ( vectorParamIndices.find( i ) == vectorParamIndices.begin() ) ? "first" : "second" ) + + ".data() )"; } } - else if ( vectorParamIndices.find( i ) != vectorParamIndices.end() ) + else + { + arguments += constructCallArgument( params[i], true ); + } + } + return arguments; +} + +std::string VulkanHppGenerator::constructCallArgumentsGetVector( std::vector const & params, + std::pair const & vectorParamIndices, + bool singular ) const +{ + std::string arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) ); + for ( size_t i = 1; i < params.size(); i++ ) + { + arguments += ", "; + if ( i == vectorParamIndices.first ) { if ( singular ) { arguments += "reinterpret_cast<" + params[i].type.type + " *>( &" + startLowerCase( stripPrefix( params[i].name, "p" ) ) + " )"; } - else if ( vectorAsNullptr ) - { - arguments += "nullptr"; - } else { - switch ( vectorParamIndices.size() ) - { - case 1: - arguments += "reinterpret_cast<" + params[i].type.type + " *>( " + - startLowerCase( stripPrefix( params[i].name, "p" ) ) + ".data() )"; - break; - case 2: - arguments += "reinterpret_cast<" + params[i].type.type + " *>( enumeratedData." + - ( ( vectorParamIndices.find( i ) == vectorParamIndices.begin() ) ? "first" : "second" ) + - ".data() )"; - break; - default: assert( false ); - } + arguments += "reinterpret_cast<" + params[i].type.type + " *>( " + + startLowerCase( stripPrefix( params[i].name, "p" ) ) + ".data() )"; } } + else if ( ( i == vectorParamIndices.second ) && singular ) + { + arguments += "sizeof( T )"; + } else { - std::string arg = params[i].name; - if ( beginsWith( params[i].type.type, "Vk" ) ) - { - if ( params[i].type.isValue() ) - { - arg = "static_cast<" + params[i].type.type + ">( " + arg + " )"; - } - else - { - if ( enhanced ) - { - arg = "&" + startLowerCase( stripPrefix( arg, "p" ) ); - } - arg = "reinterpret_cast<" + params[i].type.prefix + " " + params[i].type.type + " " + params[i].type.postfix + - ">( " + arg + " )"; - } - } - arguments += "" + arg; + arguments += constructCallArgument( params[i], true ); + } + } + return arguments; +} + +std::string + VulkanHppGenerator::constructCallArgumentsVectors( std::vector const & params, + std::map const & vectorParamIndices ) const +{ + assert( !vectorParamIndices.empty() ); + size_t countIndex = vectorParamIndices.begin()->second; + + std::string arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) ); + for ( size_t i = 1; i < params.size(); i++ ) + { + arguments += ", "; + if ( i == countIndex ) + { + arguments += startLowerCase( stripPrefix( params[vectorParamIndices.begin()->first].name, "p" ) ) + ".size()"; + } + else if ( vectorParamIndices.find( i ) != vectorParamIndices.end() ) + { + assert( !params[i].type.prefix.empty() && !params[i].type.postfix.empty() ); + arguments += "reinterpret_cast<" + params[i].type.prefix + " " + params[i].type.type + " " + + params[i].type.postfix + ">( " + startLowerCase( stripPrefix( params[i].name, "p" ) ) + ".data() )"; + } + else + { + arguments += constructCallArgument( params[i], true ); } } return arguments; @@ -3904,14 +4003,15 @@ std::string { "counterName", startLowerCase( stripPrefix( stripPluralS( commandData.params[firstVectorParamIt->second].name ), "p" ) ) }, { "counterType", commandData.params[firstVectorParamIt->second].type.type }, - { "firstCallArguments", constructCallArguments( commandData.params, vectorParamIndices, true, true, false ) }, + { "firstCallArguments", + constructCallArgumentsEnumerateVectors( commandData.params, vectorParamIndices, true ) }, { "nodiscard", nodiscard }, { "pairConstructor", withAllocators ? ( "( std::piecewise_construct, std::forward_as_tuple( " + firstVectorName + "Allocator ), std::forward_as_tuple( " + secondVectorName + "Allocator ) )" ) : "" }, { "secondCallArguments", - constructCallArguments( commandData.params, vectorParamIndices, false, true, false ) }, + constructCallArgumentsEnumerateVectors( commandData.params, vectorParamIndices, false ) }, { "templateTypeFirst", templateTypeFirst }, { "templateTypeSecond", templateTypeSecond }, { "vkCommand", name }, @@ -4050,7 +4150,8 @@ std::string VulkanHppGenerator::constructCommandGetVector( std::string const & functionTemplate, std::map( { { "argumentList", argumentList }, - { "callArguments", constructCallArguments( commandData.params, vectorParamIndices, false, true, false ) }, + { "callArguments", + constructCallArgumentsGetVector( commandData.params, *vectorParamIndices.begin(), false ) }, { "className", stripPrefix( commandData.handle, "Vk" ) }, { "commandName", commandName }, { "dataName", startLowerCase( stripPrefix( commandData.params[vectorParamIndex].name, "p" ) ) }, @@ -4170,7 +4271,7 @@ std::string VulkanHppGenerator::constructCommandGetVectorSingular( std::string c functionTemplate, std::map( { { "argumentList", argumentList }, - { "callArguments", constructCallArguments( commandData.params, vectorParamIndices, false, true, true ) }, + { "callArguments", constructCallArgumentsGetVector( commandData.params, *vectorParamIndices.begin(), true ) }, { "className", stripPrefix( commandData.handle, "Vk" ) }, { "commandName", commandName }, { "dataName", startLowerCase( stripPrefix( commandData.params[vectorParamIndex].name, "p" ) ) }, @@ -4216,15 +4317,15 @@ std::string VulkanHppGenerator::constructCommandSimple( std::string const & name return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING "::${className}::${commandName}" ); })"; - str = replaceWithMap( functionTemplate, - std::map( - { { "argumentList", argumentList }, - { "callArguments", constructCallArguments( commandData.params, {}, false, true, false ) }, - { "className", stripPrefix( commandData.handle, "Vk" ) }, - { "commandName", commandName }, - { "nodiscard", nodiscard }, - { "returnType", returnType }, - { "vkCommand", name } } ) ); + str = replaceWithMap( + functionTemplate, + std::map( { { "argumentList", argumentList }, + { "callArguments", constructCallArguments( commandData.params, true ) }, + { "className", stripPrefix( commandData.handle, "Vk" ) }, + { "commandName", commandName }, + { "nodiscard", nodiscard }, + { "returnType", returnType }, + { "vkCommand", name } } ) ); } else { @@ -4260,13 +4361,13 @@ std::string VulkanHppGenerator::constructCommandSimpleVoid( std::string const & d.${vkCommand}( ${callArguments} ); })"; - str = replaceWithMap( functionTemplate, - std::map( - { { "argumentList", argumentList }, - { "callArguments", constructCallArguments( commandData.params, {}, false, true, false ) }, - { "className", stripPrefix( commandData.handle, "Vk" ) }, - { "commandName", commandName }, - { "vkCommand", name } } ) ); + str = replaceWithMap( + functionTemplate, + std::map( { { "argumentList", argumentList }, + { "callArguments", constructCallArguments( commandData.params, true ) }, + { "className", stripPrefix( commandData.handle, "Vk" ) }, + { "commandName", commandName }, + { "vkCommand", name } } ) ); } else { @@ -4291,36 +4392,45 @@ std::string VulkanHppGenerator::constructCommandStandard( std::string const & na std::string argumentList = constructArgumentListStandard( commandData.params, { 0 } ); std::string commandName = determineCommandName( name, commandData.params[0].type.type ); std::string nodiscard = constructNoDiscardStandard( commandData ); + assert( ( commandData.returnType == "void" ) || ( commandData.returnType == "VkResult" ) ); + std::string returnType = ( commandData.returnType == "void" ) ? "void" : "Result"; if ( definition ) { + std::string functionBody = "d." + name + "( " + constructCallArguments( commandData.params, false ) + " )"; + if ( returnType != "void" ) + { + assert( returnType == "Result" ); + functionBody = "return static_cast( " + functionBody + " )"; + } + std::string const functionTemplate = R"( template - ${nodiscard}VULKAN_HPP_INLINE Result ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT + ${nodiscard}VULKAN_HPP_INLINE ${returnType} ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT { - return static_cast( d.${vkCommand}( ${callArguments} ) ); + ${functionBody}; })"; - str = replaceWithMap( functionTemplate, - std::map( { - { "argumentList", argumentList }, - { "callArguments", constructCallArguments( commandData.params, {}, true, false, false ) }, - { "className", stripPrefix( commandData.handle, "Vk" ) }, - { "commandName", commandName }, - { "nodiscard", nodiscard }, - { "vkCommand", name }, - } ) ); + str = + replaceWithMap( functionTemplate, + std::map( { { "argumentList", argumentList }, + { "className", stripPrefix( commandData.handle, "Vk" ) }, + { "commandName", commandName }, + { "functionBody", functionBody }, + { "nodiscard", nodiscard }, + { "returnType", returnType } } ) ); } else { std::string const functionTemplate = R"( template - ${nodiscard}Result ${commandName}( ${argumentList} VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;)"; + ${nodiscard}${returnType} ${commandName}( ${argumentList} VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;)"; - str = replaceWithMap( - functionTemplate, - std::map( - { { "argumentList", argumentList }, { "commandName", commandName }, { "nodiscard", nodiscard } } ) ); + str = replaceWithMap( functionTemplate, + std::map( { { "argumentList", argumentList }, + { "commandName", commandName }, + { "nodiscard", nodiscard }, + { "returnType", returnType } } ) ); } return str; } @@ -4346,7 +4456,7 @@ std::string VulkanHppGenerator::constructCommandStandardVoid( std::string const str = replaceWithMap( functionTemplate, std::map( { { "argumentList", argumentList }, - { "callArguments", constructCallArguments( commandData.params, {}, false, false, false ) }, + { "callArguments", constructCallArguments( commandData.params, false ) }, { "className", stripPrefix( commandData.handle, "Vk" ) }, { "commandName", commandName }, { "vkCommand", name }, @@ -4365,6 +4475,72 @@ std::string VulkanHppGenerator::constructCommandStandardVoid( std::string const return str; } +std::string VulkanHppGenerator::constructCommandTwoVectorsVoid( std::string const & name, + CommandData const & commandData, + std::map const & vectorParamIndices, + bool definition, + bool withAllocators ) const +{ + std::string str; + + auto firstVectorParamIt = vectorParamIndices.begin(); + auto secondVectorParamIt = std::next( firstVectorParamIt ); + + assert( commandData.params[0].type.type == commandData.handle ); + assert( firstVectorParamIt->second == secondVectorParamIt->second ); + + std::string argumentList = + constructArgumentListEnhanced( commandData.params, { 0, firstVectorParamIt->second }, definition, withAllocators ); + std::string commandName = determineCommandName( name, commandData.params[0].type.type ); + + if ( definition ) + { + const std::string functionTemplate = + R"x( template + VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( ${firstVectorName}.size() == ${secondVectorName}.size() ); +# else + if ( ${firstVectorName}.size() != ${secondVectorName}.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::${className}::${commandName}: ${firstVectorName}.size() != ${secondVectorName}.size()" ); + } +#endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + d.${vkCommand}( ${callArguments} ); + })x"; + + assert( beginsWith( commandData.params[firstVectorParamIt->first].name, "p" ) ); + std::string firstVectorName = + startLowerCase( stripPrefix( commandData.params[firstVectorParamIt->first].name, "p" ) ); + assert( beginsWith( commandData.params[secondVectorParamIt->first].name, "p" ) ); + std::string secondVectorName = + startLowerCase( stripPrefix( commandData.params[secondVectorParamIt->first].name, "p" ) ); + + str = + replaceWithMap( functionTemplate, + std::map( + { { "argumentList", argumentList }, + { "callArguments", constructCallArgumentsVectors( commandData.params, vectorParamIndices ) }, + { "className", stripPrefix( commandData.handle, "Vk" ) }, + { "commandName", commandName }, + { "firstVectorName", firstVectorName }, + { "secondVectorName", secondVectorName }, + { "vkCommand", name } } ) ); + } + else + { + const std::string functionTemplate = + R"( template + void ${commandName}( ${argumentList} ) const;)"; + + str = replaceWithMap( + functionTemplate, + std::map( { { "argumentList", argumentList }, { "commandName", commandName } } ) ); + } + return str; +} + std::string VulkanHppGenerator::constructConstexprString( std::pair const & structData ) const { diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index 27e945d..7b23fda 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -338,6 +338,11 @@ private: std::string const & name, CommandData const & commandData, bool definition ) const; + void appendCommandTwoVectorsVoid( std::string & str, + std::string const & name, + CommandData const & commandData, + std::map const & vectorParamIndices, + bool definition ) const; void appendDispatchLoaderDynamicCommand( std::string & str, std::string & emptyFunctions, std::string & deviceFunctions, @@ -523,11 +528,16 @@ private: bool withAllocators ) const; std::string constructArgumentListStandard( std::vector const & params, std::set const & skippedParams ) const; - std::string constructCallArguments( std::vector const & params, - std::map const & vectorParamIndices, - bool vectorAsNullptr, - bool enhanced, - bool singular ) const; + std::string constructCallArgument( ParamData const & param, bool enhanced ) const; + std::string constructCallArguments( std::vector const & params, bool enhanced ) const; + std::string constructCallArgumentsEnumerateVectors( std::vector const & params, + std::map const & vectorParamIndices, + bool vectorAsNullptr ) const; + std::string constructCallArgumentsGetVector( std::vector const & params, + std::pair const & vectorParamIndices, + bool singular ) const; + std::string constructCallArgumentsVectors( std::vector const & params, + std::map const & vectorParamIndices ) const; std::string constructCommandEnumerateTwoVectors( std::string const & name, CommandData const & commandData, std::map const & vectorParamIndices, @@ -558,6 +568,11 @@ private: constructCommandStandard( std::string const & name, CommandData const & commandData, bool definition ) const; std::string constructCommandStandardVoid( std::string const & name, CommandData const & commandData, bool definition ) const; + std::string constructCommandTwoVectorsVoid( std::string const & name, + CommandData const & commandData, + std::map const & vectorParamIndices, + bool definition, + bool withAllocators ) const; std::string constructConstexprString( std::pair const & structData ) const; std::string constructFunctionBodyEnhanced( std::string const & indentation, std::string const & name, diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 9108ba9..ee58f65 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -87368,6 +87368,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( pCounterBuffers ), reinterpret_cast( pCounterBufferOffsets ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( @@ -87383,7 +87384,7 @@ namespace VULKAN_HPP_NAMESPACE { throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkCommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); + "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); } # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, @@ -87551,6 +87552,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( pBuffers ), reinterpret_cast( pOffsets ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -87565,7 +87567,7 @@ namespace VULKAN_HPP_NAMESPACE if ( buffers.size() != offsets.size() ) { throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkCommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); + "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); } # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ d.vkCmdBindVertexBuffers( m_commandBuffer, @@ -87757,6 +87759,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( pInfos ), reinterpret_cast( ppOffsetInfos ) ); } + # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureKHR( @@ -87770,7 +87773,7 @@ namespace VULKAN_HPP_NAMESPACE if ( infos.size() != pOffsetInfos.size() ) { throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkCommandBuffer::buildAccelerationStructureKHR: infos.size() != pOffsetInfos.size()" ); + "::CommandBuffer::buildAccelerationStructureKHR: infos.size() != pOffsetInfos.size()" ); } # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ d.vkCmdBuildAccelerationStructureKHR( @@ -88523,6 +88526,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( pCounterBuffers ), reinterpret_cast( pCounterBufferOffsets ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( @@ -88538,7 +88542,7 @@ namespace VULKAN_HPP_NAMESPACE { throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkCommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); + "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); } # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, @@ -97556,6 +97560,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( pSwapchains ), reinterpret_cast( pMetadata ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -97569,7 +97574,7 @@ namespace VULKAN_HPP_NAMESPACE if ( swapchains.size() != metadata.size() ) { throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkDevice::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); + "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); } # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ d.vkSetHdrMetadataEXT( m_device,