From 0d02918ce8d3b6b4b0d6dae0afa8ca9ea67f1fe5 Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Thu, 24 Sep 2020 11:01:34 +0200 Subject: [PATCH] refactor more functions into the simple void case. --- VulkanHppGenerator.cpp | 400 +++++++++++++++++++++++++---------------- VulkanHppGenerator.hpp | 17 +- vulkan/vulkan.hpp | 251 ++++++++------------------ 3 files changed, 336 insertions(+), 332 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index acc55a1..e404e8b 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -1223,101 +1223,97 @@ void VulkanHppGenerator::appendCommand( std::string & str, CommandData const & commandData, bool definition ) const { - bool appendedFunction = false; - std::map vectorParamIndices = determineVectorParamIndices( commandData.params ); - switch ( vectorParamIndices.size() ) + bool appendedFunction = false; + std::map vectorParamIndices = determineVectorParamIndices( commandData.params ); + std::vector nonConstPointerParamIndices = determineNonConstPointerParamIndices( commandData.params ); + if ( nonConstPointerParamIndices.empty() ) { - case 0: + // no return parameter + std::vector constPointerParamIndices = determineConstPointerParamIndices( commandData.params ); + if ( vectorParamIndices.empty() && + std::find_if( constPointerParamIndices.begin(), constPointerParamIndices.end(), [&commandData]( size_t idx ) { + return commandData.params[idx].type.type != "void"; + } ) == constPointerParamIndices.end() ) { - // no vector parameter - std::vector nonConstPointerParamIndices = determineNonConstPointerParamIndices( commandData.params ); - if ( nonConstPointerParamIndices.empty() ) + // no vector paramter and no non-void const-pointer + if ( commandData.returnType == "void" ) { - // no return parameter - std::vector constPointerParamIndices = determineConstPointerParamIndices( commandData.params ); - if ( constPointerParamIndices.empty() ) - { - // no const-pointers in - if ( commandData.returnType == "void" ) - { - // void functions - appendCommandTrivialVoid( str, name, commandData, definition ); - appendedFunction = true; - } - } - else - { - // with const-pointer(s), - switch ( commandData.successCodes.size() ) - { - case 0: - // no success codes at all - if ( ( commandData.returnType == "void" ) && - std::find_if( - constPointerParamIndices.begin(), constPointerParamIndices.end(), [&commandData]( size_t idx ) { - return commandData.params[idx].type.type == "void"; - } ) == constPointerParamIndices.end() ) - { - // command returns void, and the const pointer(s) are void-pointers and thus can't be change from - // by-pointer to by-reference - appendCommandSimpleVoid( str, name, commandData, definition ); - appendedFunction = true; - } - break; - case 1: - // just one success code - appendCommandSimple( str, name, commandData, definition ); - appendedFunction = true; - break; - default: break; - } - } - } - } - break; - case 1: - { - // just one vector parameter - auto vectorParamIndexIt = vectorParamIndices.begin(); - if ( commandData.params[vectorParamIndexIt->first].type.isNonConstPointer() && - ( commandData.params[vectorParamIndexIt->first].type.type == "void" ) && - commandData.params[vectorParamIndexIt->second].type.isValue() ) - { - // the vector is a non-const pointer to void (that is, a return parameter), and the size is given by value - appendCommandGetVector( str, name, commandData, vectorParamIndices, definition ); + // void functions + appendCommandTrivialVoid( str, name, commandData, definition ); appendedFunction = true; } } - break; - case 2: + else { - // two vector parameters - auto firstVectorParam = vectorParamIndices.begin(); - auto secondVectorParam = std::next( firstVectorParam ); - std::vector const & params = commandData.params; - if ( ( firstVectorParam->second != INVALID_INDEX ) && ( firstVectorParam->second == secondVectorParam->second ) ) + // with const-pointers that might be changed to by-reference arguments + if ( commandData.returnType == "void" ) { - // 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() ) + appendCommandSimpleVoid( str, name, commandData, definition, vectorParamIndices ); + appendedFunction = true; + } + else if ( vectorParamIndices.empty() && ( commandData.returnType == "VkResult" ) && + ( commandData.successCodes.size() == 1 ) ) + { + // returns VkResult, but there's just one success code + appendCommandSimple( str, name, commandData, definition ); + appendedFunction = true; + } + else if ( ( vectorParamIndices.size() == 2 ) && ( vectorParamIndices.begin()->second != INVALID_INDEX ) && + ( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second ) ) + { + assert( commandData.params[vectorParamIndices.begin()->second].type.isValue() ); + if ( commandData.params[vectorParamIndices.begin()->second].type.isValue() && + ( commandData.returnType == "void" ) ) { - // 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 + // 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; - default: break; + } + else + { + switch ( vectorParamIndices.size() ) + { + case 1: + { + // just one vector parameter + auto vectorParamIndexIt = vectorParamIndices.begin(); + if ( commandData.params[vectorParamIndexIt->first].type.isNonConstPointer() && + ( commandData.params[vectorParamIndexIt->first].type.type == "void" ) && + commandData.params[vectorParamIndexIt->second].type.isValue() ) + { + // the vector is a non-const pointer to void (that is, a return parameter), and the size is given by value + appendCommandGetVector( str, name, commandData, vectorParamIndices, definition ); + appendedFunction = true; + } + } + break; + case 2: + { + // two vector parameters + auto firstVectorParam = vectorParamIndices.begin(); + auto secondVectorParam = std::next( firstVectorParam ); + std::vector const & params = commandData.params; + if ( ( firstVectorParam->second != INVALID_INDEX ) && + ( firstVectorParam->second == secondVectorParam->second ) ) + { + // 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; + } + } + } + break; + default: break; + } } if ( appendedFunction ) @@ -1681,10 +1677,11 @@ ${leave})"; { "newlineOnDefinition", definition ? "\n" : "" } } ) ); } -void VulkanHppGenerator::appendCommandSimpleVoid( std::string & str, - std::string const & name, - CommandData const & commandData, - bool definition ) const +void VulkanHppGenerator::appendCommandSimpleVoid( std::string & str, + std::string const & name, + CommandData const & commandData, + bool definition, + std::map const & vectorParamIndices ) const { const std::string functionTemplate = R"( ${enter}${commandStandard}${newlineOnDefinition} @@ -1696,13 +1693,14 @@ ${leave})"; std::string enter, leave; std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions ); - str += replaceWithMap( functionTemplate, - std::map( - { { "commandEnhanced", constructCommandSimpleVoid( name, commandData, definition ) }, - { "commandStandard", constructCommandStandardVoid( name, commandData, definition ) }, - { "enter", enter }, - { "leave", leave }, - { "newlineOnDefinition", definition ? "\n" : "" } } ) ); + str += replaceWithMap( + functionTemplate, + std::map( + { { "commandEnhanced", constructCommandSimpleVoid( name, commandData, definition, vectorParamIndices ) }, + { "commandStandard", constructCommandStandardVoid( name, commandData, definition ) }, + { "enter", enter }, + { "leave", leave }, + { "newlineOnDefinition", definition ? "\n" : "" } } ) ); } void VulkanHppGenerator::appendCommandTrivialVoid( std::string & str, @@ -2301,25 +2299,6 @@ void VulkanHppGenerator::appendEnumToString( std::string & str += " }\n"; } -bool needsMultiVectorSizeCheck( size_t returnParamIndex, std::map const & vectorParamIndices ) -{ - for ( std::map::const_iterator it0 = vectorParamIndices.begin(); it0 != vectorParamIndices.end(); - ++it0 ) - { - if ( it0->first != returnParamIndex ) - { - for ( std::map::const_iterator it1 = std::next( it0 ); it1 != vectorParamIndices.end(); ++it1 ) - { - if ( ( it1->first != returnParamIndex ) && ( it0->second == it1->second ) ) - { - return true; - } - } - } - } - return false; -} - void VulkanHppGenerator::appendFunction( std::string & str, std::string const & indentation, std::string const & name, @@ -2401,9 +2380,7 @@ void VulkanHppGenerator::appendFunction( std::string & str, // Any function that originally does not return VkResult can be marked noexcept, // if it is enhanced it must not include anything with an Allocator or needs size checks on multiple vectors bool hasAllocator = enhancedReturnType.find( "Allocator" ) != std::string::npos; - if ( !enhanced || - ( commandData.returnType != "VkResult" && - !( enhanced && ( hasAllocator || needsMultiVectorSizeCheck( returnParamIndex, vectorParamIndices ) ) ) ) ) + if ( !enhanced || ( commandData.returnType != "VkResult" && !( enhanced && hasAllocator ) ) ) { str += " VULKAN_HPP_NOEXCEPT"; } @@ -3726,19 +3703,33 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector const & "; + } + argumentList += startLowerCase( stripPrefix( params[i].name, "p" ) ); + } + else if ( beginsWith( params[i].type.type, "Vk" ) ) { if ( params[i].type.isConstPointer() ) { - if ( !params[i].len.empty() ) - { - std::string type = params[i].type.compose(); - assert( endsWith( type, "*" ) ); - type.pop_back(); - - argumentList += "ArrayProxy<" + type + "> const & " + startLowerCase( stripPrefix( params[i].name, "p" ) ); - } - else if ( params[i].optional ) + if ( params[i].optional ) { assert( params[i].type.isConstPointer() ); argumentList += "Optional " + @@ -3903,22 +3894,47 @@ std::string VulkanHppGenerator::constructCallArgumentsVectors( std::vector const & params, std::map const & vectorParamIndices ) const { - assert( !vectorParamIndices.empty() ); - size_t countIndex = vectorParamIndices.begin()->second; + std::map vectorSizeIndices; + for ( auto const & vpi : vectorParamIndices ) + { + if ( vectorSizeIndices.find( vpi.second ) == vectorSizeIndices.end() ) + { + vectorSizeIndices[vpi.second] = vpi.first; + } + } std::string arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) ); for ( size_t i = 1; i < params.size(); i++ ) { arguments += ", "; - if ( i == countIndex ) + auto vsi = vectorSizeIndices.find( i ); + if ( vsi != vectorSizeIndices.end() ) { - arguments += startLowerCase( stripPrefix( params[vectorParamIndices.begin()->first].name, "p" ) ) + ".size()"; + assert( params[i].type.isValue() ); + arguments += startLowerCase( stripPrefix( params[vsi->second].name, "p" ) ) + ".size()"; + if ( params[vsi->second].type.type == "void" ) + { + arguments += " * sizeof( T )"; + } } 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() )"; + assert( !params[i].type.isValue() ); + std::string argName = startLowerCase( stripPrefix( params[i].name, "p" ) ); + if ( beginsWith( params[i].type.type, "Vk" ) || ( params[i].type.type == "void" ) ) + { + arguments += "reinterpret_cast<" + params[i].type.prefix + " " + params[i].type.type + " " + + params[i].type.postfix + ">( " + argName + ".data()" + " )"; + } + else if ( params[i].type.type == "char" ) + { + assert( params[i].len == "null-terminated" ); + arguments += argName + ".c_str()"; + } + else + { + arguments += argName + ".data()"; + } } else { @@ -4343,41 +4359,59 @@ std::string VulkanHppGenerator::constructCommandSimple( std::string const & name return str; } -std::string VulkanHppGenerator::constructCommandSimpleVoid( std::string const & name, - CommandData const & commandData, - bool definition ) const +std::string VulkanHppGenerator::constructCommandSimpleVoid( std::string const & name, + CommandData const & commandData, + bool definition, + std::map const & vectorParamIndices ) const { std::string str; - std::string argumentList = constructArgumentListEnhanced( commandData.params, { 0 }, definition, false ); + std::set skippedParameters = { 0 }; + for ( auto const & vpi : vectorParamIndices ) + { + if ( vpi.second != INVALID_INDEX ) + { + skippedParameters.insert( vpi.second ); + } + } + + std::string argumentList = constructArgumentListEnhanced( commandData.params, skippedParameters, definition, false ); std::string commandName = determineCommandName( name, commandData.params[0].type.type ); + std::string typenameT = ( ( vectorParamIndices.size() == 1 ) && + ( commandData.params[vectorParamIndices.begin()->first].type.type == "void" ) ) + ? "typename T, " + : ""; if ( definition ) { std::string const functionTemplate = - R"( template + R"( template <${typenameT}typename Dispatch> VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT - { + {${vectorSizeCheck} d.${vkCommand}( ${callArguments} ); })"; - str = replaceWithMap( - functionTemplate, - std::map( { { "argumentList", argumentList }, - { "callArguments", constructCallArguments( commandData.params, true ) }, - { "className", stripPrefix( commandData.handle, "Vk" ) }, - { "commandName", commandName }, - { "vkCommand", name } } ) ); + str = + replaceWithMap( functionTemplate, + std::map( + { { "argumentList", argumentList }, + { "callArguments", constructCallArgumentsVectors( commandData.params, vectorParamIndices ) }, + { "className", stripPrefix( commandData.handle, "Vk" ) }, + { "commandName", commandName }, + { "typenameT", typenameT }, + { "vectorSizeCheck", constructVectorSizeCheck( name, commandData, vectorParamIndices ) }, + { "vkCommand", name } } ) ); } else { std::string const functionTemplate = - R"( template + R"( template <${typenameT}typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> void ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;)"; str = replaceWithMap( functionTemplate, - std::map( { { "argumentList", argumentList }, { "commandName", commandName } } ) ); + std::map( + { { "argumentList", argumentList }, { "commandName", commandName }, { "typenameT", typenameT } } ) ); } return str; @@ -4392,16 +4426,14 @@ 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"; + std::string returnType = stripPrefix( commandData.returnType, "Vk" ); if ( definition ) { std::string functionBody = "d." + name + "( " + constructCallArguments( commandData.params, false ) + " )"; if ( returnType != "void" ) { - assert( returnType == "Result" ); - functionBody = "return static_cast( " + functionBody + " )"; + functionBody = "return static_cast<" + returnType + ">( " + functionBody + " )"; } std::string const functionTemplate = @@ -4816,6 +4848,74 @@ std::string VulkanHppGenerator::constructSuccessCodeList( std::vector const & vectorParamIndices ) const +{ + std::string str; + + std::map> countToVectorMap; + for ( auto const & vpi : vectorParamIndices ) + { + if ( vpi.second != INVALID_INDEX ) + { + countToVectorMap[vpi.second].push_back( vpi.first ); + } + } + + // check if there's at least one count used multiple times + if ( std::find_if( countToVectorMap.begin(), countToVectorMap.end(), []( auto const & cvm ) { + return 1 < cvm.second.size(); + } ) != countToVectorMap.end() ) + { + std::string const assertTemplate = + " VULKAN_HPP_ASSERT( ${firstVectorName}.size() == ${secondVectorName}.size() );"; + std::string const throwTemplate = + R"#( if ( ${firstVectorName}.size() != ${secondVectorName}.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::${className}::${commandName}: ${firstVectorName}.size() != ${secondVectorName}.size()" ); + })#"; + + std::string commandName = determineCommandName( name, commandData.params[0].type.type ); + + std::string assertions, throws; + for ( auto const & cvm : countToVectorMap ) + { + for ( size_t i = 1; i < cvm.second.size(); i++ ) + { + assertions += replaceWithMap( + assertTemplate, + { { "firstVectorName", startLowerCase( stripPrefix( commandData.params[cvm.second[0]].name, "p" ) ) }, + { "secondVectorName", startLowerCase( stripPrefix( commandData.params[cvm.second[i]].name, "p" ) ) } } ); + throws += replaceWithMap( + throwTemplate, + { { "firstVectorName", startLowerCase( stripPrefix( commandData.params[cvm.second[0]].name, "p" ) ) }, + { "secondVectorName", startLowerCase( stripPrefix( commandData.params[cvm.second[i]].name, "p" ) ) }, + { "className", stripPrefix( commandData.handle, "Vk" ) }, + { "commandName", commandName } } ); + if ( i + 1 < cvm.second.size() ) + { + assertions += "\n"; + throws += "\n"; + } + } + } + + std::string const sizeCheckTemplate = + R"#( +#ifdef VULKAN_HPP_NO_EXCEPTIONS +${assertions} +#else +${throws} +#endif /*VULKAN_HPP_NO_EXCEPTIONS*/ +)#"; + + str = replaceWithMap( sizeCheckTemplate, { { "assertions", assertions }, { "throws", throws } } ); + } + + return str; +} + template std::vector findAll( InputIt first, InputIt last, UnaryPredicate p ) { diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index 7b23fda..82e894b 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -330,10 +330,11 @@ private: std::string const & name, CommandData const & commandData, bool definition ) const; - void appendCommandSimpleVoid( std::string & str, - std::string const & name, - CommandData const & commandData, - bool definition ) const; + void appendCommandSimpleVoid( std::string & str, + std::string const & name, + CommandData const & commandData, + bool definition, + std::map const & vectorParamIndices ) const; void appendCommandTrivialVoid( std::string & str, std::string const & name, CommandData const & commandData, @@ -562,8 +563,10 @@ private: bool definition ) const; std::string constructCommandSimple( std::string const & name, CommandData const & commandData, bool definition ) const; - std::string - constructCommandSimpleVoid( std::string const & name, CommandData const & commandData, bool definition ) const; + std::string constructCommandSimpleVoid( std::string const & name, + CommandData const & commandData, + bool definition, + std::map const & vectorParamIndices ) const; std::string constructCommandStandard( std::string const & name, CommandData const & commandData, bool definition ) const; std::string @@ -608,6 +611,8 @@ private: std::string constructNoDiscardStandard( CommandData const & commandData ) const; std::string constructReturnType( CommandData const & commandData, std::string const & baseType ) const; std::string constructSuccessCodeList( std::vector const & successCodes ) const; + std::string constructVectorSizeCheck( std::string const & name, CommandData const & commandData, + std::map const & vectorParamIndices ) const; void checkCorrectness(); bool containsArray( std::string const & type ) const; bool containsUnion( std::string const & type ) const; diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index f35e0f8..6ff235e 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -37933,7 +37933,8 @@ namespace VULKAN_HPP_NAMESPACE void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy const & counterBuffers, ArrayProxy const & counterBufferOffsets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const + VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -37993,7 +37994,8 @@ namespace VULKAN_HPP_NAMESPACE ArrayProxy const & buffers, ArrayProxy const & offsets, ArrayProxy const & sizes, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const + VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -38007,7 +38009,7 @@ namespace VULKAN_HPP_NAMESPACE void bindVertexBuffers( uint32_t firstBinding, ArrayProxy const & buffers, ArrayProxy const & offsets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -38025,7 +38027,7 @@ namespace VULKAN_HPP_NAMESPACE ArrayProxy const & offsets, ArrayProxy const & sizes, ArrayProxy const & strides, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -38088,7 +38090,7 @@ namespace VULKAN_HPP_NAMESPACE void buildAccelerationStructureKHR( ArrayProxy const & infos, ArrayProxy const & pOffsetInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -38537,10 +38539,11 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template - void endTransformFeedbackEXT( uint32_t firstCounterBuffer, - ArrayProxy const & counterBuffers, - ArrayProxy const & counterBufferOffsets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + void + endTransformFeedbackEXT( uint32_t firstCounterBuffer, + ArrayProxy const & counterBuffers, + ArrayProxy const & counterBufferOffsets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -38675,7 +38678,6 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::PipelineLayout layout, @@ -38683,15 +38685,6 @@ namespace VULKAN_HPP_NAMESPACE const void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - template - void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t set, - const void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const - VULKAN_HPP_NOEXCEPT; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template void resetEvent( VULKAN_HPP_NAMESPACE::Event event, @@ -38735,15 +38728,9 @@ namespace VULKAN_HPP_NAMESPACE void setBlendConstants( const float blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - template - void setCheckpointNV( const void * pCheckpointMarker, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template void @@ -55446,7 +55433,7 @@ namespace VULKAN_HPP_NAMESPACE template void setHdrMetadataEXT( ArrayProxy const & swapchains, ArrayProxy const & metadata, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -55464,11 +55451,11 @@ namespace VULKAN_HPP_NAMESPACE #else template typename ResultValueType::type - setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType, - uint64_t objectHandle, - VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, - uint64_t data, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType, + uint64_t objectHandle, + VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, + uint64_t data, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -55511,37 +55498,19 @@ namespace VULKAN_HPP_NAMESPACE void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - template - void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, - VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, - const void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const - VULKAN_HPP_NOEXCEPT; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, const void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - template - void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, - VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, - const void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const - VULKAN_HPP_NOEXCEPT; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template void updateDescriptorSets( uint32_t descriptorWriteCount, @@ -88666,7 +88635,7 @@ namespace VULKAN_HPP_NAMESPACE int32_t messageCode, const std::string & layerPrefix, const std::string & message, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template @@ -89328,7 +89297,7 @@ namespace VULKAN_HPP_NAMESPACE uint32_t firstCounterBuffer, ArrayProxy const & counterBuffers, ArrayProxy const & counterBufferOffsets, - Dispatch const & d ) const + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { # ifdef VULKAN_HPP_NO_EXCEPTIONS VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() ); @@ -89340,6 +89309,7 @@ namespace VULKAN_HPP_NAMESPACE "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); } # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBuffers.size(), @@ -89367,6 +89337,7 @@ namespace VULKAN_HPP_NAMESPACE dynamicOffsetCount, pDynamicOffsets ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -89447,6 +89418,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( pOffsets ), reinterpret_cast( pSizes ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -89454,35 +89426,24 @@ namespace VULKAN_HPP_NAMESPACE ArrayProxy const & buffers, ArrayProxy const & offsets, ArrayProxy const & sizes, - Dispatch const & d ) const + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { # ifdef VULKAN_HPP_NO_EXCEPTIONS VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); + VULKAN_HPP_ASSERT( buffers.size() == sizes.size() ); # else if ( buffers.size() != offsets.size() ) { throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkCommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" ); + "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" ); } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( buffers.size() == sizes.size() ); -# else if ( buffers.size() != sizes.size() ) { throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkCommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( offsets.size() == sizes.size() ); -# else - if ( offsets.size() != sizes.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkCommandBuffer::bindTransformFeedbackBuffersEXT: offsets.size() != sizes.size()" ); + "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" ); } # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, firstBinding, buffers.size(), @@ -89512,7 +89473,7 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer::bindVertexBuffers( uint32_t firstBinding, ArrayProxy const & buffers, ArrayProxy const & offsets, - Dispatch const & d ) const + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { # ifdef VULKAN_HPP_NO_EXCEPTIONS VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); @@ -89523,6 +89484,7 @@ namespace VULKAN_HPP_NAMESPACE "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); } # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + d.vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, buffers.size(), @@ -89548,6 +89510,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( pSizes ), reinterpret_cast( pStrides ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -89556,62 +89519,30 @@ namespace VULKAN_HPP_NAMESPACE ArrayProxy const & offsets, ArrayProxy const & sizes, ArrayProxy const & strides, - Dispatch const & d ) const + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { # ifdef VULKAN_HPP_NO_EXCEPTIONS VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); + VULKAN_HPP_ASSERT( buffers.size() == sizes.size() ); + VULKAN_HPP_ASSERT( buffers.size() == strides.size() ); # else if ( buffers.size() != offsets.size() ) { throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkCommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" ); + "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" ); } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( buffers.size() == sizes.size() ); -# else if ( buffers.size() != sizes.size() ) { throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkCommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" ); + "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" ); } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( buffers.size() == strides.size() ); -# else if ( buffers.size() != strides.size() ) { throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkCommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( offsets.size() == sizes.size() ); -# else - if ( offsets.size() != sizes.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkCommandBuffer::bindVertexBuffers2EXT: offsets.size() != sizes.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( offsets.size() == strides.size() ); -# else - if ( offsets.size() != strides.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkCommandBuffer::bindVertexBuffers2EXT: offsets.size() != strides.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( sizes.size() == strides.size() ); -# else - if ( sizes.size() != strides.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkCommandBuffer::bindVertexBuffers2EXT: sizes.size() != strides.size()" ); + "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" ); } # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + d.vkCmdBindVertexBuffers2EXT( m_commandBuffer, firstBinding, buffers.size(), @@ -89641,6 +89572,7 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( pRegions ), static_cast( filter ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, @@ -89734,7 +89666,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureKHR( ArrayProxy const & infos, ArrayProxy const & pOffsetInfos, - Dispatch const & d ) const + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { # ifdef VULKAN_HPP_NO_EXCEPTIONS VULKAN_HPP_ASSERT( infos.size() == pOffsetInfos.size() ); @@ -89745,6 +89677,7 @@ namespace VULKAN_HPP_NAMESPACE "::CommandBuffer::buildAccelerationStructureKHR: infos.size() != pOffsetInfos.size()" ); } # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + d.vkCmdBuildAccelerationStructureKHR( m_commandBuffer, infos.size(), @@ -89815,6 +89748,7 @@ namespace VULKAN_HPP_NAMESPACE rectCount, reinterpret_cast( pRects ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -89845,6 +89779,7 @@ namespace VULKAN_HPP_NAMESPACE rangeCount, reinterpret_cast( pRanges ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -89879,6 +89814,7 @@ namespace VULKAN_HPP_NAMESPACE rangeCount, reinterpret_cast( pRanges ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -89966,6 +89902,7 @@ namespace VULKAN_HPP_NAMESPACE regionCount, reinterpret_cast( pRegions ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, @@ -90013,6 +89950,7 @@ namespace VULKAN_HPP_NAMESPACE regionCount, reinterpret_cast( pRegions ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -90067,6 +90005,7 @@ namespace VULKAN_HPP_NAMESPACE regionCount, reinterpret_cast( pRegions ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, @@ -90117,6 +90056,7 @@ namespace VULKAN_HPP_NAMESPACE regionCount, reinterpret_cast( pRegions ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -90573,7 +90513,7 @@ namespace VULKAN_HPP_NAMESPACE uint32_t firstCounterBuffer, ArrayProxy const & counterBuffers, ArrayProxy const & counterBufferOffsets, - Dispatch const & d ) const + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { # ifdef VULKAN_HPP_NO_EXCEPTIONS VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() ); @@ -90585,6 +90525,7 @@ namespace VULKAN_HPP_NAMESPACE "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); } # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBuffers.size(), @@ -90601,6 +90542,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkCmdExecuteCommands( m_commandBuffer, commandBufferCount, reinterpret_cast( pCommandBuffers ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -90743,6 +90685,7 @@ namespace VULKAN_HPP_NAMESPACE imageMemoryBarrierCount, reinterpret_cast( pImageMemoryBarriers ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( @@ -90802,6 +90745,7 @@ namespace VULKAN_HPP_NAMESPACE size, pValues ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, @@ -90835,6 +90779,7 @@ namespace VULKAN_HPP_NAMESPACE descriptorWriteCount, reinterpret_cast( pDescriptorWrites ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( @@ -90853,7 +90798,6 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, @@ -90868,22 +90812,6 @@ namespace VULKAN_HPP_NAMESPACE set, pData ); } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( - VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t set, - const void * pData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, - static_cast( descriptorUpdateTemplate ), - static_cast( layout ), - set, - pData ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template VULKAN_HPP_INLINE void CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event event, @@ -90919,6 +90847,7 @@ namespace VULKAN_HPP_NAMESPACE regionCount, reinterpret_cast( pRegions ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -90963,21 +90892,12 @@ namespace VULKAN_HPP_NAMESPACE d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants ); } -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker ); } -#else - template - VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void * pCheckpointMarker, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template VULKAN_HPP_INLINE void @@ -90991,6 +90911,7 @@ namespace VULKAN_HPP_NAMESPACE customSampleOrderCount, reinterpret_cast( pCustomSampleOrders ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( @@ -91082,6 +91003,7 @@ namespace VULKAN_HPP_NAMESPACE discardRectangleCount, reinterpret_cast( pDiscardRectangles ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -91115,6 +91037,7 @@ namespace VULKAN_HPP_NAMESPACE exclusiveScissorCount, reinterpret_cast( pExclusiveScissors ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -91246,6 +91169,7 @@ namespace VULKAN_HPP_NAMESPACE { d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast( pScissors ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, @@ -91264,6 +91188,7 @@ namespace VULKAN_HPP_NAMESPACE { d.vkCmdSetScissorWithCountEXT( m_commandBuffer, scissorCount, reinterpret_cast( pScissors ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -91331,6 +91256,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast( pViewports ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, @@ -91354,6 +91280,7 @@ namespace VULKAN_HPP_NAMESPACE viewportCount, reinterpret_cast( pShadingRatePalettes ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( @@ -91381,6 +91308,7 @@ namespace VULKAN_HPP_NAMESPACE viewportCount, reinterpret_cast( pViewportWScalings ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( @@ -91403,6 +91331,7 @@ namespace VULKAN_HPP_NAMESPACE d.vkCmdSetViewportWithCountEXT( m_commandBuffer, viewportCount, reinterpret_cast( pViewports ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -91547,6 +91476,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( dataSize ), pData ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, @@ -91588,6 +91518,7 @@ namespace VULKAN_HPP_NAMESPACE imageMemoryBarrierCount, reinterpret_cast( pImageMemoryBarriers ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -91631,6 +91562,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( queryPool ), firstQuery ); } + # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR( @@ -91668,6 +91600,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( queryPool ), firstQuery ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( @@ -96245,6 +96178,7 @@ namespace VULKAN_HPP_NAMESPACE commandBufferCount, reinterpret_cast( pCommandBuffers ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -96270,6 +96204,7 @@ namespace VULKAN_HPP_NAMESPACE commandBufferCount, reinterpret_cast( pCommandBuffers ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void Device::free( VULKAN_HPP_NAMESPACE::CommandPool commandPool, @@ -99623,7 +99558,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy const & swapchains, ArrayProxy const & metadata, - Dispatch const & d ) const + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { # ifdef VULKAN_HPP_NO_EXCEPTIONS VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() ); @@ -99634,6 +99569,7 @@ namespace VULKAN_HPP_NAMESPACE "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); } # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + d.vkSetHdrMetadataEXT( m_device, swapchains.size(), reinterpret_cast( swapchains.data() ), @@ -99751,7 +99687,6 @@ namespace VULKAN_HPP_NAMESPACE d.vkUnmapMemory( m_device, static_cast( memory ) ); } -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, @@ -99764,22 +99699,7 @@ namespace VULKAN_HPP_NAMESPACE static_cast( descriptorUpdateTemplate ), pData ); } -#else - template - VULKAN_HPP_INLINE void - Device::updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, - VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, - const void * pData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - d.vkUpdateDescriptorSetWithTemplate( m_device, - static_cast( descriptorSet ), - static_cast( descriptorUpdateTemplate ), - pData ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, @@ -99792,20 +99712,6 @@ namespace VULKAN_HPP_NAMESPACE static_cast( descriptorUpdateTemplate ), pData ); } -#else - template - VULKAN_HPP_INLINE void - Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet, - VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, - const void * pData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - d.vkUpdateDescriptorSetWithTemplateKHR( m_device, - static_cast( descriptorSet ), - static_cast( descriptorUpdateTemplate ), - pData ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ template VULKAN_HPP_INLINE void @@ -99821,6 +99727,7 @@ namespace VULKAN_HPP_NAMESPACE descriptorCopyCount, reinterpret_cast( pDescriptorCopies ) ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void @@ -100810,6 +100717,7 @@ namespace VULKAN_HPP_NAMESPACE pLayerPrefix, pMessage ); } + #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE template VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, @@ -100819,17 +100727,8 @@ namespace VULKAN_HPP_NAMESPACE int32_t messageCode, const std::string & layerPrefix, const std::string & message, - Dispatch const & d ) const + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( layerPrefix.size() == message.size() ); -# else - if ( layerPrefix.size() != message.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VkInstance::debugReportMessageEXT: layerPrefix.size() != message.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ d.vkDebugReportMessageEXT( m_instance, static_cast( flags ), static_cast( objectType ),