Change C-arrays as command arguments to std::arrays (#2561)

Author: asuessenbach

README.md

@@ -77,6 +77,15 @@ Requests for updates and issues with these packages should be directed to their
 
 We try to keep the API for all flavours of Vulkan-Hpp constant or backwards compatible. However, we may introduce unavoidable breaking changes, usually to fix bugs. Following is a list of those changes, arranged by version.
 
+### v1.4.351
+
+In order to improve argument safety, the interface of functions taking a C-array of values has changed to take a `std::array`, instead.
+The affected functions are:
+- `vk::CommandBuffer::setFragmentShadingRateKHR`
+- `vk::raii::CommandBuffer::setBlendConstants`
+- `vk::raii::CommandBuffer::setFragmentShadingRateKHR`
+- `vk::raii::CommandBuffer::setFragmentShadingRateEnumNV`
+
 ### v1.4.334
 
 The `vulkan_hpp` C++ named module has been renamed to `vulkan`.

generator/VulkanHppGenerator.cpp

@@ -2350,14 +2350,19 @@ std::string VulkanHppGenerator::generateArgumentListEnhanced( std::vector<ParamD
         assert( composedType.ends_with( " *" ) );
         arguments.push_back( stripPostfix( composedType, " *" ) + " & " + stripPluralS( startLowerCase( stripPrefix( params[i].name, "p" ) ) ) );
       }
+      else if ( !params[i].arraySizes.empty() )
+      {
+        assert( params[i].arraySizes.size() == 1 );
+        assert( params[i].type.postfix == "const" );
+        arguments.push_back( "std::array<" + stripPrefix( params[i].type.name, "Vk" ) + ", " + params[i].arraySizes[0] + "> const & " + params[i].name );
+      }
       else if ( params[i].type.isConstPointer() )
       {
         assert( composedType.ends_with( " *" ) );
         std::string name = startLowerCase( stripPrefix( params[i].name, "p" ) );
         if ( params[i].lenExpression.empty() )
         {
           assert( withDispatcher || !isHandleType( params[i].type.name ) );
-          assert( params[i].arraySizes.empty() );
           if ( params[i].type.name == "void" )
           {
             arguments.push_back( templatedParams.contains( i ) ? ( stripPrefix( params[i].name, "p" ) + "Type const & " + name )
@@ -2378,7 +2383,6 @@ std::string VulkanHppGenerator::generateArgumentListEnhanced( std::vector<ParamD
         {
           // a const-pointer with a non-empty len is either null-terminated (aka a string) or represented by an
           // ArrayProxy
-          assert( params[i].arraySizes.empty() );
           if ( params[i].lenExpression == "null-terminated" )
           {
             assert( params[i].type.name == "char" );
@@ -2431,7 +2435,7 @@ std::string VulkanHppGenerator::generateArgumentListEnhanced( std::vector<ParamD
         assert( params[i].type.isValue() );
         // parameters named "objectType" collide with the member variable -> append an _ to here
         std::string paramName = ( definition && ( params[i].name == "objectType" ) ) ? "objectType_" : params[i].name;
-        arguments.push_back( composedType + " " + paramName + generateCArraySizes( params[i].arraySizes ) );
+        arguments.push_back( composedType + " " + paramName );
       }
       arguments.back() += std::string( !definition && ( defaultStartIndex <= i ) && !hasDefaultAssignment ? " VULKAN_HPP_DEFAULT_ASSIGNMENT( {} )" : "" );
     }
@@ -2999,9 +3003,9 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedValue(
   std::string       argument;
   ParamData const & param = params[paramIndex];
   assert( ( flavourFlags & CommandFlavourFlagBits::keepVoidPtr ) || param.lenExpression.empty() );  // !keepVoidPtr -> no lenExpression
-  if ( param.type.name.starts_with( "Vk" ) )
+  if ( param.arraySizes.empty() )
   {
-    if ( param.arraySizes.empty() )
+    if ( param.type.name.starts_with( "Vk" ) )
     {
       // check if this param is used as the len of an other param
       auto pointerIt = std::ranges::find_if( params, [&param]( ParamData const & pd ) { return pd.lenExpression == param.name; } );
@@ -3038,57 +3042,55 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedValue(
     }
     else
     {
-      assert( !param.optional );
-      assert( param.arraySizes.size() == 1 );
-      assert( param.type.postfix == "const" );
-      argument = "reinterpret_cast<" + param.type.compose( "" ) + " *>( " + param.name + " )";
-    }
-  }
-  else
-  {
-    auto pointerIt = std::ranges::find_if( params, [&param]( ParamData const & pd ) { return pd.lenExpression == param.name; } );
-    if ( ( pointerIt != params.end() ) && !( ( pointerIt->type.name == "void" ) && ( flavourFlags & CommandFlavourFlagBits::keepVoidPtr ) ) )
-    {
-      // this parameter is the len of some other -> replace it with that parameter's size
-      assert( param.arraySizes.empty() );
-      assert( ( param.type.name == "size_t" ) || ( param.type.name == "uint32_t" ) );
-      if ( singularParams.contains( paramIndex ) )
+      auto pointerIt = std::ranges::find_if( params, [&param]( ParamData const & pd ) { return pd.lenExpression == param.name; } );
+      if ( ( pointerIt != params.end() ) && !( ( pointerIt->type.name == "void" ) && ( flavourFlags & CommandFlavourFlagBits::keepVoidPtr ) ) )
       {
-        if ( pointerIt->type.name == "void" )
+        // this parameter is the len of some other -> replace it with that parameter's size
+        assert( ( param.type.name == "size_t" ) || ( param.type.name == "uint32_t" ) );
+        if ( singularParams.contains( paramIndex ) )
         {
-          argument = "sizeof( " + stripPrefix( pointerIt->name, "p" ) + "Type )";
+          if ( pointerIt->type.name == "void" )
+          {
+            argument = "sizeof( " + stripPrefix( pointerIt->name, "p" ) + "Type )";
+          }
+          else
+          {
+            argument = "1";
+          }
         }
         else
         {
-          argument = "1";
+          argument = startLowerCase( stripPrefix( pointerIt->name, "p" ) ) + ".size()";
+          if ( pointerIt->type.name == "void" )
+          {
+            argument += " * sizeof( " + stripPrefix( pointerIt->name, "p" ) + "Type )";
+          }
         }
       }
       else
       {
-        argument = startLowerCase( stripPrefix( pointerIt->name, "p" ) ) + ".size()";
-        if ( pointerIt->type.name == "void" )
+        pointerIt = std::ranges::find_if( params, [paramIndex]( ParamData const & pd ) { return pd.strideParam.second == paramIndex; } );
+        if ( pointerIt != params.end() )
         {
-          argument += " * sizeof( " + stripPrefix( pointerIt->name, "p" ) + "Type )";
+          // this parameter is the stride of some other -> replace it with that parameter's stride
+          assert( param.type.name == "uint32_t" );
+          assert( pointerIt->strideParam.first == param.name );
+          argument = startLowerCase( stripPrefix( pointerIt->name, "p" ) ) + ".stride()";
+        }
+        else
+        {
+          argument = param.name;
         }
       }
     }
-    else
-    {
-      assert( param.arraySizes.size() <= 1 );
-      pointerIt = std::ranges::find_if( params, [paramIndex]( ParamData const & pd ) { return pd.strideParam.second == paramIndex; } );
-      if ( pointerIt != params.end() )
-      {
-        // this parameter is the stride of some other -> replace it with that parameter's stride
-        assert( param.arraySizes.empty() );
-        assert( param.type.name == "uint32_t" );
-        assert( pointerIt->strideParam.first == param.name );
-        argument = startLowerCase( stripPrefix( pointerIt->name, "p" ) ) + ".stride()";
-      }
-      else
-      {
-        argument = param.name;
-      }
-    }
+  }
+  else
+  {
+    assert( !param.optional );
+    assert( param.arraySizes.size() == 1 );
+    assert( param.type.postfix == "const" );
+    argument = param.type.name.starts_with( "Vk" ) ? ( "reinterpret_cast<" + param.type.compose( "" ) + " *>( " + param.name + ".data() )" )
+                                                   : ( param.name + ".data()" );
   }
   return argument;
 }
@@ -12849,7 +12851,7 @@ bool VulkanHppGenerator::hasParentHandle( std::string const & handle, std::strin
 
 bool VulkanHppGenerator::hasPointerParams( std::vector<ParamData> const & params ) const
 {
-  return std::ranges::any_of( params, []( auto const & pd ) { return pd.type.isPointer(); } );
+  return std::ranges::any_of( params, []( auto const & pd ) { return pd.type.isPointer() || !pd.arraySizes.empty(); } );
 }
 
 bool VulkanHppGenerator::isDeviceCommand( CommandData const & commandData ) const

vulkan/vulkan_funcs.hpp

@@ -5336,6 +5336,20 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     d.vkCmdSetBlendConstants( static_cast<VkCommandBuffer>( m_commandBuffer ), blendConstants );
   }
 
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html
+  template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkCmdSetBlendConstants ), bool>::type>
+  VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( std::array<float, 4> const & blendConstants, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetBlendConstants && "Function <vkCmdSetBlendConstants> requires <VK_VERSION_1_0>" );
+#  endif
+
+    d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants.data() );
+  }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
   // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html
   template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkCmdSetDepthBounds ), bool>::type>
   VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
@@ -20943,15 +20957,16 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
   // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html
   template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkCmdSetFragmentShadingRateKHR ), bool>::type>
   VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR(
-    Extent2D const & fragmentSize, FragmentShadingRateCombinerOpKHR const combinerOps[2], Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+    Extent2D const & fragmentSize, std::array<FragmentShadingRateCombinerOpKHR, 2> const & combinerOps, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
   {
     VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
 #  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
     VULKAN_HPP_ASSERT( d.vkCmdSetFragmentShadingRateKHR && "Function <vkCmdSetFragmentShadingRateKHR> requires <VK_KHR_fragment_shading_rate>" );
 #  endif
 
-    d.vkCmdSetFragmentShadingRateKHR(
-      m_commandBuffer, reinterpret_cast<VkExtent2D const *>( &fragmentSize ), reinterpret_cast<VkFragmentShadingRateCombinerOpKHR const *>( combinerOps ) );
+    d.vkCmdSetFragmentShadingRateKHR( m_commandBuffer,
+                                      reinterpret_cast<VkExtent2D const *>( &fragmentSize ),
+                                      reinterpret_cast<VkFragmentShadingRateCombinerOpKHR const *>( combinerOps.data() ) );
   }
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
 
@@ -24939,6 +24954,24 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
                                          reinterpret_cast<VkFragmentShadingRateCombinerOpKHR const *>( combinerOps ) );
   }
 
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html
+  template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkCmdSetFragmentShadingRateEnumNV ), bool>::type>
+  VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV(
+    FragmentShadingRateNV shadingRate, std::array<FragmentShadingRateCombinerOpKHR, 2> const & combinerOps, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdSetFragmentShadingRateEnumNV && "Function <vkCmdSetFragmentShadingRateEnumNV> requires <VK_NV_fragment_shading_rate_enums>" );
+#  endif
+
+    d.vkCmdSetFragmentShadingRateEnumNV( m_commandBuffer,
+                                         static_cast<VkFragmentShadingRateNV>( shadingRate ),
+                                         reinterpret_cast<VkFragmentShadingRateCombinerOpKHR const *>( combinerOps.data() ) );
+  }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
   //=== VK_EXT_mesh_shader ===
 
   // wrapper function for command vkCmdDrawMeshTasksEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksEXT.html

vulkan/vulkan_handles.hpp

@@ -5729,6 +5729,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<IS_DISPATCHED( vkCmdSetBlendConstants ), bool>::type = true>
     void setBlendConstants( float const blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<IS_DISPATCHED( vkCmdSetBlendConstants ), bool>::type = true>
+    void setBlendConstants( std::array<float, 4> const & blendConstants,
+                            Dispatch const & d           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
 
     // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<IS_DISPATCHED( vkCmdSetDepthBounds ), bool>::type = true>
@@ -7289,9 +7295,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html
     template <typename Dispatch                                                                    = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
               typename std::enable_if<IS_DISPATCHED( vkCmdSetFragmentShadingRateKHR ), bool>::type = true>
-    void setFragmentShadingRateKHR( Extent2D const &                       fragmentSize,
-                                    FragmentShadingRateCombinerOpKHR const combinerOps[2],
-                                    Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+    void setFragmentShadingRateKHR( Extent2D const &                                        fragmentSize,
+                                    std::array<FragmentShadingRateCombinerOpKHR, 2> const & combinerOps,
+                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
 
     //=== VK_KHR_dynamic_rendering_local_read ===
@@ -7953,6 +7959,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
     void setFragmentShadingRateEnumNV( FragmentShadingRateNV                  shadingRate,
                                        FragmentShadingRateCombinerOpKHR const combinerOps[2],
                                        Dispatch const & d                     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html
+    template <typename Dispatch                                                                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
+              typename std::enable_if<IS_DISPATCHED( vkCmdSetFragmentShadingRateEnumNV ), bool>::type = true>
+    void setFragmentShadingRateEnumNV( FragmentShadingRateNV                                   shadingRate,
+                                       std::array<FragmentShadingRateCombinerOpKHR, 2> const & combinerOps,
+                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
 
     //=== VK_EXT_mesh_shader ===