refactor more functions into the simple void case.

VulkanHppGenerator.cpp

@@ -1223,101 +1223,97 @@ void VulkanHppGenerator::appendCommand( std::string &       str,
                                         CommandData const & commandData,
                                         bool                definition ) const
 {
-  bool                     appendedFunction   = false;
+  bool                     appendedFunction            = false;
-  std::map<size_t, size_t> vectorParamIndices = determineVectorParamIndices( commandData.params );
+  std::map<size_t, size_t> vectorParamIndices          = determineVectorParamIndices( commandData.params );
-  switch ( vectorParamIndices.size() )
+  std::vector<size_t>      nonConstPointerParamIndices = determineNonConstPointerParamIndices( commandData.params );
+  if ( nonConstPointerParamIndices.empty() )
   {
-    case 0:
+    // no return parameter
+    std::vector<size_t> 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
+      // no vector paramter and no non-void const-pointer
-      std::vector<size_t> nonConstPointerParamIndices = determineNonConstPointerParamIndices( commandData.params );
+      if ( commandData.returnType == "void" )
-      if ( nonConstPointerParamIndices.empty() )
       {
-        // no return parameter
+        // void functions
-        std::vector<size_t> constPointerParamIndices = determineConstPointerParamIndices( commandData.params );
+        appendCommandTrivialVoid( str, name, commandData, definition );
-        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 );
         appendedFunction = true;
       }
     }
-    break;
+    else
-    case 2:
     {
-      // two vector parameters
+      // with const-pointers that might be changed to by-reference arguments
-      auto                           firstVectorParam  = vectorParamIndices.begin();
+      if ( commandData.returnType == "void" )
-      auto                           secondVectorParam = std::next( firstVectorParam );
-      std::vector<ParamData> const & params            = commandData.params;
-      if ( ( firstVectorParam->second != INVALID_INDEX ) && ( firstVectorParam->second == secondVectorParam->second ) )
       {
-        // the two vectors use the very same size parameter
+        appendCommandSimpleVoid( str, name, commandData, definition, vectorParamIndices );
-        if ( params[firstVectorParam->first].type.isNonConstPointer() &&
+        appendedFunction = true;
-             params[secondVectorParam->first].type.isNonConstPointer() &&
+      }
-             params[firstVectorParam->second].type.isNonConstPointer() )
+      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
+          // size is given by value and the vectors are const pointers, that is input parameters; function returns
-          appendCommandEnumerateTwoVectors( str, name, commandData, vectorParamIndices, definition );
+          // void
-          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;
+  }
-    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<ParamData> 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,
+void VulkanHppGenerator::appendCommandSimpleVoid( std::string &                    str,
-                                                  std::string const & name,
+                                                  std::string const &              name,
-                                                  CommandData const & commandData,
+                                                  CommandData const &              commandData,
-                                                  bool                definition ) const
+                                                  bool                             definition,
+                                                  std::map<size_t, size_t> 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,
+  str += replaceWithMap(
-                         std::map<std::string, std::string>(
+    functionTemplate,
-                           { { "commandEnhanced", constructCommandSimpleVoid( name, commandData, definition ) },
+    std::map<std::string, std::string>(
-                             { "commandStandard", constructCommandStandardVoid( name, commandData, definition ) },
+      { { "commandEnhanced", constructCommandSimpleVoid( name, commandData, definition, vectorParamIndices ) },
-                             { "enter", enter },
+        { "commandStandard", constructCommandStandardVoid( name, commandData, definition ) },
-                             { "leave", leave },
+        { "enter", enter },
-                             { "newlineOnDefinition", definition ? "\n" : "" } } ) );
+        { "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<size_t, size_t> const & vectorParamIndices )
-{
-  for ( std::map<size_t, size_t>::const_iterator it0 = vectorParamIndices.begin(); it0 != vectorParamIndices.end();
-        ++it0 )
-  {
-    if ( it0->first != returnParamIndex )
-    {
-      for ( std::map<size_t, size_t>::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 ||
+  if ( !enhanced || ( commandData.returnType != "VkResult" && !( enhanced && hasAllocator ) ) )
-       ( commandData.returnType != "VkResult" &&
-         !( enhanced && ( hasAllocator || needsMultiVectorSizeCheck( returnParamIndex, vectorParamIndices ) ) ) ) )
   {
     str += " VULKAN_HPP_NOEXCEPT";
   }
@@ -3726,19 +3703,33 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector<Param
   {
     if ( skippedParams.find( i ) == skippedParams.end() )
     {
-      if ( beginsWith( params[i].type.type, "Vk" ) )
+      if ( params[i].type.isConstPointer() && !params[i].len.empty() )
+      {
+        if ( params[i].len == "null-terminated" )
+        {
+          assert( params[i].type.type == "char" );
+          argumentList += "const std::string & ";
+        }
+        else
+        {
+          std::string type = params[i].type.compose();
+          assert( endsWith( type, "*" ) );
+          type.pop_back();
+          size_t pos = type.find( "void" );
+          if ( pos != std::string::npos )
+          {
+            type.replace( pos, 4, "T" );
+          }
+
+          argumentList += "ArrayProxy<" + type + "> 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() )
+          if ( params[i].optional )
-          {
-            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 )
           {
             assert( params[i].type.isConstPointer() );
             argumentList += "Optional<const " + stripPrefix( params[i].type.type, "Vk" ) + "> " +
@@ -3903,22 +3894,47 @@ std::string
   VulkanHppGenerator::constructCallArgumentsVectors( std::vector<ParamData> const &   params,
                                                      std::map<size_t, size_t> const & vectorParamIndices ) const
 {
-  assert( !vectorParamIndices.empty() );
+  std::map<size_t, size_t> vectorSizeIndices;
-  size_t countIndex = vectorParamIndices.begin()->second;
+  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() );
+      assert( !params[i].type.isValue() );
-      arguments += "reinterpret_cast<" + params[i].type.prefix + " " + params[i].type.type + " " +
+      std::string argName = startLowerCase( stripPrefix( params[i].name, "p" ) );
-                   params[i].type.postfix + ">( " + startLowerCase( stripPrefix( params[i].name, "p" ) ) + ".data() )";
+      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,
+std::string VulkanHppGenerator::constructCommandSimpleVoid( std::string const &              name,
-                                                            CommandData const & commandData,
+                                                            CommandData const &              commandData,
-                                                            bool                definition ) const
+                                                            bool                             definition,
+                                                            std::map<size_t, size_t> const & vectorParamIndices ) const
 {
   std::string str;
 
-  std::string argumentList = constructArgumentListEnhanced( commandData.params, { 0 }, definition, false );
+  std::set<size_t> 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 <typename Dispatch>
+      R"(  template <${typenameT}typename Dispatch>
   VULKAN_HPP_INLINE void ${className}::${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT
-  {
+  {${vectorSizeCheck}
     d.${vkCommand}( ${callArguments} );
   })";
 
-    str = replaceWithMap(
+    str =
-      functionTemplate,
+      replaceWithMap( functionTemplate,
-      std::map<std::string, std::string>( { { "argumentList", argumentList },
+                      std::map<std::string, std::string>(
-                                            { "callArguments", constructCallArguments( commandData.params, true ) },
+                        { { "argumentList", argumentList },
-                                            { "className", stripPrefix( commandData.handle, "Vk" ) },
+                          { "callArguments", constructCallArgumentsVectors( commandData.params, vectorParamIndices ) },
-                                            { "commandName", commandName },
+                          { "className", stripPrefix( commandData.handle, "Vk" ) },
-                                            { "vkCommand", name } } ) );
+                          { "commandName", commandName },
+                          { "typenameT", typenameT },
+                          { "vectorSizeCheck", constructVectorSizeCheck( name, commandData, vectorParamIndices ) },
+                          { "vkCommand", name } } ) );
   }
   else
   {
     std::string const functionTemplate =
-      R"(    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+      R"(    template <${typenameT}typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void ${commandName}( ${argumentList} ) const VULKAN_HPP_NOEXCEPT;)";
 
     str = replaceWithMap(
       functionTemplate,
-      std::map<std::string, std::string>( { { "argumentList", argumentList }, { "commandName", commandName } } ) );
+      std::map<std::string, std::string>(
+        { { "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   = stripPrefix( commandData.returnType, "Vk" );
-  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<" + returnType + ">( " + functionBody + " )";
-      functionBody = "return static_cast<Result>( " + functionBody + " )";
     }
 
     std::string const functionTemplate =
@@ -4816,6 +4848,74 @@ std::string VulkanHppGenerator::constructSuccessCodeList( std::vector<std::strin
   return successCodeList;
 }
 
+std::string VulkanHppGenerator::constructVectorSizeCheck( std::string const &              name,
+                                                          CommandData const &              commandData,
+                                                          std::map<size_t, size_t> const & vectorParamIndices ) const
+{
+  std::string str;
+
+  std::map<size_t, std::vector<size_t>> 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 <class InputIt, class UnaryPredicate>
 std::vector<InputIt> findAll( InputIt first, InputIt last, UnaryPredicate p )
 {

VulkanHppGenerator.hpp

@@ -330,10 +330,11 @@ private:
                                    std::string const & name,
                                    CommandData const & commandData,
                                    bool                definition ) const;
-  void        appendCommandSimpleVoid( std::string &       str,
+  void        appendCommandSimpleVoid( std::string &                    str,
-                                       std::string const & name,
+                                       std::string const &              name,
-                                       CommandData const & commandData,
+                                       CommandData const &              commandData,
-                                       bool                definition ) const;
+                                       bool                             definition,
+                                       std::map<size_t, size_t> 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
+  std::string constructCommandSimpleVoid( std::string const &              name,
-    constructCommandSimpleVoid( std::string const & name, CommandData const & commandData, bool definition ) const;
+                                          CommandData const &              commandData,
+                                          bool                             definition,
+                                          std::map<size_t, size_t> 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<std::string> const & successCodes ) const;
+  std::string constructVectorSizeCheck( std::string const & name, CommandData const &   commandData,
+                                        std::map<size_t, size_t> const & vectorParamIndices ) const;
   void        checkCorrectness();
   bool        containsArray( std::string const & type ) const;
   bool        containsUnion( std::string const & type ) const;

vulkan/vulkan.hpp

@@ -37933,7 +37933,8 @@ namespace VULKAN_HPP_NAMESPACE
     void beginTransformFeedbackEXT( uint32_t                                                   firstCounterBuffer,
                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> 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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -37993,7 +37994,8 @@ namespace VULKAN_HPP_NAMESPACE
                                           ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
                                           ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
                                           ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> 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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -38007,7 +38009,7 @@ namespace VULKAN_HPP_NAMESPACE
     void bindVertexBuffers( uint32_t                                                   firstBinding,
                             ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
                             ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> 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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -38025,7 +38027,7 @@ namespace VULKAN_HPP_NAMESPACE
                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,
                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> 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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -38088,7 +38090,7 @@ namespace VULKAN_HPP_NAMESPACE
     void buildAccelerationStructureKHR(
       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &       infos,
       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildOffsetInfoKHR * const> 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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void endTransformFeedbackEXT( uint32_t                                                   firstCounterBuffer,
+    void
-                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
+      endTransformFeedbackEXT( uint32_t                                                   firstCounterBuffer,
-                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets,
+                               ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
-                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+                               ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets,
+                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void setCheckpointNV( const void *       pCheckpointMarker,
                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#else
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void setCheckpointNV( const void *       pCheckpointMarker,
-                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void
@@ -55446,7 +55433,7 @@ namespace VULKAN_HPP_NAMESPACE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
                             ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> 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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -55464,11 +55451,11 @@ namespace VULKAN_HPP_NAMESPACE
 #else
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     typename ResultValueType<void>::type
-      setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
+         setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
-                         uint64_t                                 objectHandle,
+                            uint64_t                                 objectHandle,
-                         VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
+                            VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
-                         uint64_t                                 data,
+                            uint64_t                                 data,
-                         Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+                            Dispatch const & d                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
@@ -89328,7 +89297,7 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t                                                   firstCounterBuffer,
     ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
     ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> 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 <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -89447,6 +89418,7 @@ namespace VULKAN_HPP_NAMESPACE
                                             reinterpret_cast<const VkDeviceSize *>( pOffsets ),
                                             reinterpret_cast<const VkDeviceSize *>( pSizes ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -89454,35 +89426,24 @@ namespace VULKAN_HPP_NAMESPACE
                                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
                                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
                                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> 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()" );
+                        "::CommandBuffer::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()" );
     }
 #  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 VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
                                       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> 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<const VkDeviceSize *>( pSizes ),
                                   reinterpret_cast<const VkDeviceSize *>( pStrides ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -89556,62 +89519,30 @@ namespace VULKAN_HPP_NAMESPACE
                                           ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
                                           ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,
                                           ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> 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()" );
+                        "::CommandBuffer::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()" );
     }
 #  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
+
     d.vkCmdBindVertexBuffers2EXT( m_commandBuffer,
                                   firstBinding,
                                   buffers.size(),
@@ -89641,6 +89572,7 @@ namespace VULKAN_HPP_NAMESPACE
                       reinterpret_cast<const VkImageBlit *>( pRegions ),
                       static_cast<VkFilter>( filter ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   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 VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &       infos,
     ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildOffsetInfoKHR * const> 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<const VkClearRect *>( pRects ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -89845,6 +89779,7 @@ namespace VULKAN_HPP_NAMESPACE
                             rangeCount,
                             reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -89879,6 +89814,7 @@ namespace VULKAN_HPP_NAMESPACE
                                    rangeCount,
                                    reinterpret_cast<const VkImageSubresourceRange *>( pRanges ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -89966,6 +89902,7 @@ namespace VULKAN_HPP_NAMESPACE
                        regionCount,
                        reinterpret_cast<const VkBufferCopy *>( pRegions ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
@@ -90013,6 +89950,7 @@ namespace VULKAN_HPP_NAMESPACE
                               regionCount,
                               reinterpret_cast<const VkBufferImageCopy *>( pRegions ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -90067,6 +90005,7 @@ namespace VULKAN_HPP_NAMESPACE
                       regionCount,
                       reinterpret_cast<const VkImageCopy *>( pRegions ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image       srcImage,
@@ -90117,6 +90056,7 @@ namespace VULKAN_HPP_NAMESPACE
                               regionCount,
                               reinterpret_cast<const VkBufferImageCopy *>( pRegions ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -90573,7 +90513,7 @@ namespace VULKAN_HPP_NAMESPACE
     uint32_t                                                   firstCounterBuffer,
     ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
     ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> 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<const VkCommandBuffer *>( pCommandBuffers ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -90743,6 +90685,7 @@ namespace VULKAN_HPP_NAMESPACE
                             imageMemoryBarrierCount,
                             reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier(
@@ -90802,6 +90745,7 @@ namespace VULKAN_HPP_NAMESPACE
                           size,
                           pValues );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename T, typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
@@ -90835,6 +90779,7 @@ namespace VULKAN_HPP_NAMESPACE
                                  descriptorWriteCount,
                                  reinterpret_cast<const VkWriteDescriptorSet *>( pDescriptorWrites ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   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 <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR(
     VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
@@ -90868,22 +90812,6 @@ namespace VULKAN_HPP_NAMESPACE
                                              set,
                                              pData );
   }
-#else
-  template <typename Dispatch>
-  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<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-                                             static_cast<VkPipelineLayout>( layout ),
-                                             set,
-                                             pData );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
@@ -90919,6 +90847,7 @@ namespace VULKAN_HPP_NAMESPACE
                          regionCount,
                          reinterpret_cast<const VkImageResolve *>( pRegions ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -90963,21 +90892,12 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants );
   }
 
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void *     pCheckpointMarker,
                                                          Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker );
   }
-#else
-  template <typename Dispatch>
-  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 <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -90991,6 +90911,7 @@ namespace VULKAN_HPP_NAMESPACE
                                    customSampleOrderCount,
                                    reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( pCustomSampleOrders ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV(
@@ -91082,6 +91003,7 @@ namespace VULKAN_HPP_NAMESPACE
                                    discardRectangleCount,
                                    reinterpret_cast<const VkRect2D *>( pDiscardRectangles ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -91115,6 +91037,7 @@ namespace VULKAN_HPP_NAMESPACE
                                   exclusiveScissorCount,
                                   reinterpret_cast<const VkRect2D *>( pExclusiveScissors ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -91246,6 +91169,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t                                               firstScissor,
@@ -91264,6 +91188,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
     d.vkCmdSetScissorWithCountEXT( m_commandBuffer, scissorCount, reinterpret_cast<const VkRect2D *>( pScissors ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -91331,6 +91256,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkCmdSetViewport(
       m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport,
@@ -91354,6 +91280,7 @@ namespace VULKAN_HPP_NAMESPACE
                                             viewportCount,
                                             reinterpret_cast<const VkShadingRatePaletteNV *>( pShadingRatePalettes ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV(
@@ -91381,6 +91308,7 @@ namespace VULKAN_HPP_NAMESPACE
                                   viewportCount,
                                   reinterpret_cast<const VkViewportWScalingNV *>( pViewportWScalings ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV(
@@ -91403,6 +91331,7 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkCmdSetViewportWithCountEXT(
       m_commandBuffer, viewportCount, reinterpret_cast<const VkViewport *>( pViewports ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -91547,6 +91476,7 @@ namespace VULKAN_HPP_NAMESPACE
                          static_cast<VkDeviceSize>( dataSize ),
                          pData );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename T, typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
@@ -91588,6 +91518,7 @@ namespace VULKAN_HPP_NAMESPACE
                        imageMemoryBarrierCount,
                        reinterpret_cast<const VkImageMemoryBarrier *>( pImageMemoryBarriers ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -91631,6 +91562,7 @@ namespace VULKAN_HPP_NAMESPACE
       static_cast<VkQueryPool>( queryPool ),
       firstQuery );
   }
+
 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR(
@@ -91668,6 +91600,7 @@ namespace VULKAN_HPP_NAMESPACE
       static_cast<VkQueryPool>( queryPool ),
       firstQuery );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV(
@@ -96245,6 +96178,7 @@ namespace VULKAN_HPP_NAMESPACE
                             commandBufferCount,
                             reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -96270,6 +96204,7 @@ namespace VULKAN_HPP_NAMESPACE
                             commandBufferCount,
                             reinterpret_cast<const VkCommandBuffer *>( pCommandBuffers ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   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 VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
                                ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> 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<const VkSwapchainKHR *>( swapchains.data() ),
@@ -99751,7 +99687,6 @@ namespace VULKAN_HPP_NAMESPACE
     d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
   }
 
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
     Device::updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
@@ -99764,22 +99699,7 @@ namespace VULKAN_HPP_NAMESPACE
                                          static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
                                          pData );
   }
-#else
-  template <typename Dispatch>
-  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<VkDescriptorSet>( descriptorSet ),
-                                         static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-                                         pData );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
     Device::updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
@@ -99792,20 +99712,6 @@ namespace VULKAN_HPP_NAMESPACE
                                             static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
                                             pData );
   }
-#else
-  template <typename Dispatch>
-  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<VkDescriptorSet>( descriptorSet ),
-                                            static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
-                                            pData );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -99821,6 +99727,7 @@ namespace VULKAN_HPP_NAMESPACE
                               descriptorCopyCount,
                               reinterpret_cast<const VkCopyDescriptorSet *>( pDescriptorCopies ) );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   VULKAN_HPP_INLINE void
@@ -100810,6 +100717,7 @@ namespace VULKAN_HPP_NAMESPACE
                                pLayerPrefix,
                                pMessage );
   }
+
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
   template <typename Dispatch>
   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<VkDebugReportFlagsEXT>( flags ),
                                static_cast<VkDebugReportObjectTypeEXT>( objectType ),