Update and adjustments to VK_VULKAN_HEADER 143

Vulkan-Headers

@@ -1 +1 @@
-Subproject commit 09531f27933bf04bffde9074acb302e026e8f181
+Subproject commit 9d2dfca53b754dd3ab916899fed567a5290c30aa

VulkanHppGenerator.cpp

@@ -2767,7 +2767,7 @@ void VulkanHppGenerator::appendFunctionHeaderArgumentEnhancedVector( std::string
   else
   {
     // it's a non-char vector (they are never optional)
-    //assert( !optional );
+    assert( !optional );
     if ( singular )
     {
       // in singular case, change from pointer to reference
@@ -3132,8 +3132,8 @@ void VulkanHppGenerator::appendHandle( std::string &
         // special handling for destroy functions
         bool platformLeft = false;
         if ( commandIt->second.alias.empty() &&
-               ( ( commandIt->first.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) ||
+             ( ( ( commandIt->first.substr( 2, 7 ) == "Destroy" ) && ( commandName != "destroy" ) ) ||
-             ( commandIt->first.substr( 2, 4 ) == "Free" ) )
+               ( commandIt->first.substr( 2, 4 ) == "Free" ) ) )
         {
           assert( 1 < commandIt->second.params.size() );
           auto handleIt = m_handles.find( commandIt->second.params[1].type.type );
@@ -4252,15 +4252,29 @@ void VulkanHppGenerator::checkCorrectness()
     }
     for ( auto const & member : structure.second.members )
     {
-      if ( !member.values.empty() )
+      if ( !member.selector.empty() )
       {
-        assert( member.name == "sType" );
+        std::string const & selector   = member.selector;
-        check( std::find_if( structureTypeIt->second.values.begin(),
+        auto                selectorIt = std::find_if( structure.second.members.begin(),
-                             structureTypeIt->second.values.end(),
+                                        structure.second.members.end(),
-                             [&member]( auto const & evd ) { return member.values == evd.vulkanValue; } ) !=
+                                        [&selector]( MemberData const & md ) { return md.name == selector; } );
-                 structureTypeIt->second.values.end(),
+        assert( selectorIt != structure.second.members.end() );
-               member.xmlLine,
+        auto enumIt = m_enums.find( selectorIt->type.type );
-               "sType value <" + member.values + "> not listed for VkStructureType" );
+        assert( enumIt != m_enums.end() );
+        auto dataIt = m_structures.find( member.type.type );
+        assert( ( dataIt != m_structures.end() ) && dataIt->second.isUnion );
+        for ( auto const & data : dataIt->second.members )
+        {
+          assert( !data.selection.empty() );
+          std::string const & selection = data.selection;
+          check( std::find_if( enumIt->second.values.begin(),
+                               enumIt->second.values.end(),
+                               [&selection]( EnumValueData const & evd ) { return evd.vulkanValue == selection; } ) !=
+                   enumIt->second.values.end(),
+                 data.xmlLine,
+                 "union member <" + data.name + "> uses selection <" + selection +
+                   "> that is not part of the selector type <" + selectorIt->type.type + ">" );
+        }
       }
       check( m_types.find( member.type.type ) != m_types.end(),
              member.xmlLine,
@@ -4271,6 +4285,16 @@ void VulkanHppGenerator::checkCorrectness()
                member.xmlLine,
                "struct member array size uses unknown constant <" + member.usedConstant + ">" );
       }
+      if ( !member.values.empty() )
+      {
+        assert( member.name == "sType" );
+        check( std::find_if( structureTypeIt->second.values.begin(),
+                             structureTypeIt->second.values.end(),
+                             [&member]( auto const & evd ) { return member.values == evd.vulkanValue; } ) !=
+                 structureTypeIt->second.values.end(),
+               member.xmlLine,
+               "sType value <" + member.values + "> not listed for VkStructureType" );
+      }
     }
   }
 
@@ -4327,43 +4351,6 @@ void VulkanHppGenerator::checkCorrectness()
   }
 }
 
-bool VulkanHppGenerator::checkLenAttribute( std::string const & len, std::vector<ParamData> const & params )
-{
-  // simple: "null-terminated" or previously encountered parameter
-  if ( ( len == "null-terminated" ) || ( std::find_if( params.begin(), params.end(), [&len]( ParamData const & pd ) {
-                                           return pd.name == len;
-                                         } ) != params.end() ) )
-  {
-    return true;
-  }
-
-  // check if len specifies a member of a struct
-  std::vector<std::string> lenParts = tokenize( len, "->" );
-  if ( lenParts.size() == 1 )
-  {
-    // older versions of vk.xml used the notation parameter::member
-    lenParts = tokenize( len, "::" );
-  }
-  if ( lenParts.size() == 2 )
-  {
-    auto paramIt =
-      std::find_if( params.begin(), params.end(), [&l = lenParts[0]]( ParamData const & pd ) { return pd.name == l; } );
-    if ( paramIt != params.end() )
-    {
-      auto structureIt = m_structures.find( paramIt->type.type );
-      if ( ( structureIt != m_structures.end() ) && ( std::find_if( structureIt->second.members.begin(),
-                                                                    structureIt->second.members.end(),
-                                                                    [&n = lenParts[1]]( MemberData const & md ) {
-                                                                      return md.name == n;
-                                                                    } ) != structureIt->second.members.end() ) )
-      {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
 bool VulkanHppGenerator::containsArray( std::string const & type ) const
 {
   // a simple recursive check if a type is or contains an array
@@ -4568,12 +4555,7 @@ std::map<size_t, size_t> VulkanHppGenerator::determineVectorParamIndices( std::v
         std::make_pair( std::distance( params.begin(), it ),
                         ( findIt < it ) ? std::distance( params.begin(), findIt ) : INVALID_INDEX ) );
       assert( ( vectorParamIndices[std::distance( params.begin(), it )] != INVALID_INDEX ) ||
-              ( it->len == "null-terminated" ) || ( it->len == "pAllocateInfo->descriptorSetCount" ) ||
+              ( it->len == "null-terminated" ) || isParamIndirect( it->len, params ) );
-              ( it->len == "pAllocateInfo::descriptorSetCount" ) ||
-              ( it->len == "pAllocateInfo->commandBufferCount" ) ||
-              ( it->len == "pAllocateInfo::commandBufferCount" ) ||
-              ( it->len == "pBuildInfo->geometryCount")
-      );
     }
   }
   return vectorParamIndices;
@@ -4720,6 +4702,38 @@ bool VulkanHppGenerator::holdsSType( std::string const & type ) const
   return false;
 }
 
+bool VulkanHppGenerator::isParam( std::string const & name, std::vector<ParamData> const & params ) const
+{
+  return std::find_if( params.begin(), params.end(), [&name]( ParamData const & pd ) { return pd.name == name; } ) !=
+         params.end();
+}
+
+bool VulkanHppGenerator::isParamIndirect( std::string const & name, std::vector<ParamData> const & params ) const
+{
+  // check if name specifies a member of a struct
+  std::vector<std::string> nameParts = tokenize( name, "->" );
+  if ( nameParts.size() == 1 )
+  {
+    // older versions of vk.xml used the notation parameter::member
+    nameParts = tokenize( name, "::" );
+  }
+  if ( nameParts.size() == 2 )
+  {
+    auto paramIt = std::find_if(
+      params.begin(), params.end(), [&n = nameParts[0]]( ParamData const & pd ) { return pd.name == n; } );
+    if ( paramIt != params.end() )
+    {
+      auto structureIt = m_structures.find( paramIt->type.type );
+      return ( structureIt != m_structures.end() ) && ( std::find_if( structureIt->second.members.begin(),
+                                                                      structureIt->second.members.end(),
+                                                                      [&n = nameParts[1]]( MemberData const & md ) {
+                                                                        return md.name == n;
+                                                                      } ) != structureIt->second.members.end() );
+    }
+  }
+  return false;
+}
+
 bool VulkanHppGenerator::isTwoStepAlgorithm( std::vector<ParamData> const & params ) const
 {
   // we generate a two-step algorithm for functions returning a vector of stuff, where the length is specified as a
@@ -5002,7 +5016,8 @@ VulkanHppGenerator::ParamData VulkanHppGenerator::readCommandParam( tinyxml2::XM
     if ( attribute.first == "len" )
     {
       paramData.len = attribute.second;
-      check( checkLenAttribute( paramData.len, params ),
+      check( ( paramData.len == "null-terminated" ) || isParam( paramData.len, params ) ||
+               isParamIndirect( paramData.len, params ),
              line,
              "command param len <" + paramData.len + "> is not recognized as a valid len value" );
     }
@@ -6252,8 +6267,8 @@ void VulkanHppGenerator::readStruct( tinyxml2::XMLElement const *
     assert( !name.empty() );
     // make this warn a check, as soon as vk.xml has been fixed on attribute "allowduplicate" !
     warn( !allowDuplicate || !structExtends.empty(),
-           line,
+          line,
-           "attribute <allowduplicate> is true, but no structures are listed in <structextends>" );
+          "attribute <allowduplicate> is true, but no structures are listed in <structextends>" );
 
     check( m_structures.find( name ) == m_structures.end(), line, "struct <" + name + "> already specfied" );
     std::map<std::string, StructureData>::iterator it =
@@ -6271,7 +6286,7 @@ void VulkanHppGenerator::readStruct( tinyxml2::XMLElement const *
       }
       else if ( value == "member" )
       {
-        readStructMember( child, it->second.members );
+        readStructMember( child, it->second.members, isUnion );
       }
     }
     it->second.subStruct = determineSubStruct( *it );
@@ -6318,7 +6333,9 @@ void VulkanHppGenerator::readStructAlias( tinyxml2::XMLElement const *
          "struct <" + name + "> already specified as a type" );
 }
 
-void VulkanHppGenerator::readStructMember( tinyxml2::XMLElement const * element, std::vector<MemberData> & members )
+void VulkanHppGenerator::readStructMember( tinyxml2::XMLElement const * element,
+                                           std::vector<MemberData> &    members,
+                                           bool                         isUnion )
 {
   int                                line       = element->GetLineNum();
   std::map<std::string, std::string> attributes = getAttributes( element );
@@ -6330,6 +6347,8 @@ void VulkanHppGenerator::readStructMember( tinyxml2::XMLElement const * element,
                      { "len", {} },
                      { "noautovalidity", { "true" } },
                      { "optional", { "false", "true" } },
+                     { "selection", {} },
+                     { "selector", {} },
                      { "values", {} } } );
   std::vector<tinyxml2::XMLElement const *> children = getChildElements( element );
   checkElements( line, children, { { "name", true }, { "type", true } }, { "comment", "enum" } );
@@ -6354,16 +6373,34 @@ void VulkanHppGenerator::readStructMember( tinyxml2::XMLElement const * element,
     }
   }
 
-  auto valuesIt = attributes.find( "values" );
+  for ( auto const & attribute : attributes )
-  if ( valuesIt != attributes.end() )
   {
-    check( memberData.name == "sType",
+    if ( attribute.first == "selection" )
-           line,
+    {
-           "Structure member named differently than <sType> with attribute <values> encountered: " );
+      check( isUnion, line, "attribute <selection> is used with a non-union structure." );
-    check( m_sTypeValues.insert( valuesIt->second ).second,
+      memberData.selection = attribute.second;
-           line,
+    }
-           "<" + valuesIt->second + "> already encountered as values for the sType member of a struct" );
+    else if ( attribute.first == "selector" )
-    memberData.values = valuesIt->second;
+    {
+      memberData.selector            = attribute.second;
+      std::string const & selector   = memberData.selector;
+      auto                selectorIt = std::find_if(
+        members.begin(), members.end(), [selector]( MemberData const & md ) { return md.name == selector; } );
+      check( selectorIt != members.end(), line, "member attribute <selector> holds unknown value <" + selector + ">" );
+      check( m_enums.find( selectorIt->type.type ) != m_enums.end(),
+             line,
+             "member attribute <selector> references unknown enum type <" + selectorIt->type.type + ">" );
+    }
+    else if ( attribute.first == "values" )
+    {
+      check( memberData.name == "sType",
+             line,
+             "Structure member named differently than <sType> with attribute <values> encountered: " );
+      check( m_sTypeValues.insert( attribute.second ).second,
+             line,
+             "<" + attribute.second + "> already encountered as values for the sType member of a struct" );
+      memberData.values = attribute.second;
+    }
   }
 }
 

VulkanHppGenerator.hpp

@@ -149,11 +149,11 @@ private:
                    std::string const & obsoletedBy_,
                    std::string const & platform_,
                    std::string const & promotedTo_ )
-      : xmlLine( line )
+      : deprecatedBy( deprecatedBy_ )
-      , deprecatedBy( deprecatedBy_ )
       , obsoletedBy( obsoletedBy_ )
       , platform( platform_ )
       , promotedTo( promotedTo_ )
+      , xmlLine( line )
     {}
 
     std::string                deprecatedBy;
@@ -193,6 +193,8 @@ private:
     std::string              name;
     std::vector<std::string> arraySizes;
     std::string              bitCount;
+    std::string              selection;
+    std::string              selector;
     std::string              values;
     std::string              usedConstant;
     int                      xmlLine;
@@ -207,9 +209,7 @@ private:
 
   struct StructureData
   {
-    StructureData( std::vector<std::string> const & extends, int line )
+    StructureData( std::vector<std::string> const & extends, int line ) : structExtends( extends ), xmlLine( line ) {}
-      : structExtends( extends ), xmlLine( line )
-    {}
 
     bool                     allowDuplicate = false;
     bool                     isUnion        = false;
@@ -499,7 +499,6 @@ private:
                                  std::set<std::string> const & childrenTypes ) const;
   std::string constructConstexprString( std::pair<std::string, StructureData> const & structData ) const;
   void        checkCorrectness();
-  bool        checkLenAttribute( std::string const & len, std::vector<ParamData> const & params );
   bool        containsArray( std::string const & type ) const;
   bool        containsUnion( std::string const & type ) const;
   std::string determineEnhancedReturnType( CommandData const &              commandData,
@@ -517,6 +516,8 @@ private:
                                                           std::set<std::string> const & extension ) const;
   std::pair<std::string, std::string> generateProtection( std::string const & type, bool isAliased ) const;
   bool                                holdsSType( std::string const & type ) const;
+  bool                                isParam( std::string const & name, std::vector<ParamData> const & params ) const;
+  bool                                isParamIndirect( std::string const & name, std::vector<ParamData> const & params ) const;
   bool                                isTwoStepAlgorithm( std::vector<ParamData> const & params ) const;
   void readBaseType( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
   void readBitmask( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
@@ -582,7 +583,7 @@ private:
                    bool                                       isUnion,
                    std::map<std::string, std::string> const & attributes );
   void readStructAlias( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
-  void readStructMember( tinyxml2::XMLElement const * element, std::vector<MemberData> & members );
+  void readStructMember( tinyxml2::XMLElement const * element, std::vector<MemberData> & members, bool isUnion );
   void readStructMemberEnum( tinyxml2::XMLElement const * element, MemberData & memberData );
   void readStructMemberName( tinyxml2::XMLElement const *    element,
                              MemberData &                    memberData,

vulkan/vulkan.hpp

@@ -1,32 +1,6 @@
 // Copyright (c) 2015-2020 The Khronos Group Inc.
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
+// SPDX-License-Identifier: Apache-2.0 OR MIT
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// ---- Exceptions to the Apache 2.0 License: ----
-//
-// As an exception, if you use this Software to generate code and portions of
-// this Software are embedded into the generated code as a result, you may
-// redistribute such product without providing attribution as would otherwise
-// be required by Sections 4(a), 4(b) and 4(d) of the License.
-//
-// In addition, if you combine or link code generated by this Software with
-// software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1
-// ("`Combined Software`") and if a court of competent jurisdiction determines
-// that the patent provision (Section 3), the indemnity provision (Section 9)
-// or other Section of the License conflicts with the conditions of the
-// applicable GPL or LGPL license, you may retroactively and prospectively
-// choose to deem waived or otherwise exclude such Section(s) of the License,
-// but only in their entirety and only with respect to the Combined Software.
 //
 
 // This header is generated from the Khronos Vulkan XML API Registry.
@@ -78,7 +52,7 @@
 #  include <compare>
 #endif
 
-static_assert( VK_HEADER_VERSION == 141, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 143, "Wrong VK_HEADER_VERSION!" );
 
 // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
 // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
@@ -5104,15 +5078,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
-  enum class BufferViewCreateFlagBits
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlagBits )
-  {
-    return "(void)";
-  }
-
   enum class BuildAccelerationStructureFlagBitsKHR : VkBuildAccelerationStructureFlagsKHR
   {
     eAllowUpdate     = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR,
@@ -7837,15 +7802,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
-  enum class PipelineColorBlendStateCreateFlagBits
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits )
-  {
-    return "(void)";
-  }
-
   enum class PipelineCompilerControlFlagBitsAMD : VkPipelineCompilerControlFlagsAMD
   {
   };
@@ -7924,24 +7880,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
-  enum class PipelineDepthStencilStateCreateFlagBits
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits )
-  {
-    return "(void)";
-  }
-
-  enum class PipelineDynamicStateCreateFlagBits
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlagBits )
-  {
-    return "(void)";
-  }
-
   enum class PipelineExecutableStatisticFormatKHR
   {
     eBool32  = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR,
@@ -7962,42 +7900,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
-  enum class PipelineInputAssemblyStateCreateFlagBits
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlagBits )
-  {
-    return "(void)";
-  }
-
-  enum class PipelineLayoutCreateFlagBits
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits )
-  {
-    return "(void)";
-  }
-
-  enum class PipelineMultisampleStateCreateFlagBits
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits )
-  {
-    return "(void)";
-  }
-
-  enum class PipelineRasterizationStateCreateFlagBits
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlagBits )
-  {
-    return "(void)";
-  }
-
   enum class PipelineShaderStageCreateFlagBits : VkPipelineShaderStageCreateFlags
   {
     eAllowVaryingSubgroupSizeEXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT,
@@ -8080,33 +7982,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
-  enum class PipelineTessellationStateCreateFlagBits
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlagBits )
-  {
-    return "(void)";
-  }
-
-  enum class PipelineVertexInputStateCreateFlagBits
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlagBits )
-  {
-    return "(void)";
-  }
-
-  enum class PipelineViewportStateCreateFlagBits
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlagBits )
-  {
-    return "(void)";
-  }
-
   enum class PointClippingBehavior
   {
     eAllClipPlanes      = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
@@ -10886,6 +10761,15 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
+  enum class BufferViewCreateFlagBits : VkFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlagBits )
+  {
+    return "(void)";
+  }
+
   using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlags )
@@ -13667,6 +13551,15 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
+  enum class PipelineColorBlendStateCreateFlagBits : VkFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
   using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlags )
@@ -13875,6 +13768,15 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
+  enum class PipelineDepthStencilStateCreateFlagBits : VkFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
   using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlags )
@@ -13898,6 +13800,15 @@ namespace VULKAN_HPP_NAMESPACE
     return "{}";
   }
 
+  enum class PipelineDynamicStateCreateFlagBits : VkFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
   using PipelineDynamicStateCreateFlags = Flags<PipelineDynamicStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlags )
@@ -13905,6 +13816,15 @@ namespace VULKAN_HPP_NAMESPACE
     return "{}";
   }
 
+  enum class PipelineInputAssemblyStateCreateFlagBits : VkFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
   using PipelineInputAssemblyStateCreateFlags = Flags<PipelineInputAssemblyStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlags )
@@ -13912,6 +13832,15 @@ namespace VULKAN_HPP_NAMESPACE
     return "{}";
   }
 
+  enum class PipelineLayoutCreateFlagBits : VkFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits )
+  {
+    return "(void)";
+  }
+
   using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlags )
@@ -13919,6 +13848,15 @@ namespace VULKAN_HPP_NAMESPACE
     return "{}";
   }
 
+  enum class PipelineMultisampleStateCreateFlagBits : VkFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
   using PipelineMultisampleStateCreateFlags = Flags<PipelineMultisampleStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlags )
@@ -13959,6 +13897,15 @@ namespace VULKAN_HPP_NAMESPACE
     return "{}";
   }
 
+  enum class PipelineRasterizationStateCreateFlagBits : VkFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
   using PipelineRasterizationStateCreateFlags = Flags<PipelineRasterizationStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlags )
@@ -14142,6 +14089,15 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
+  enum class PipelineTessellationStateCreateFlagBits : VkFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
   using PipelineTessellationStateCreateFlags = Flags<PipelineTessellationStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlags )
@@ -14149,6 +14105,15 @@ namespace VULKAN_HPP_NAMESPACE
     return "{}";
   }
 
+  enum class PipelineVertexInputStateCreateFlagBits : VkFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
   using PipelineVertexInputStateCreateFlags = Flags<PipelineVertexInputStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlags )
@@ -14156,6 +14121,15 @@ namespace VULKAN_HPP_NAMESPACE
     return "{}";
   }
 
+  enum class PipelineViewportStateCreateFlagBits : VkFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
   using PipelineViewportStateCreateFlags = Flags<PipelineViewportStateCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlags )
@@ -24365,7 +24339,7 @@ namespace VULKAN_HPP_NAMESPACE
     typename ResultValueType<void>::type
       resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool           descriptorPool,
                            VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(),
-                           Dispatch const &                               d     = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
+                           Dispatch const &                               d = VULKAN_HPP_DEFAULT_DISPATCHER ) const;
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
@@ -94919,6 +94893,14 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
   template <>
+  struct StructExtends<DevicePrivateDataCreateInfoEXT, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
   struct StructExtends<DeviceQueueGlobalPriorityCreateInfoEXT, DeviceQueueCreateInfo>
   {
     enum
@@ -96023,6 +96005,22 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
   template <>
+  struct StructExtends<PhysicalDevicePrivateDataFeaturesEXT, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
+  struct StructExtends<PhysicalDevicePrivateDataFeaturesEXT, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+  template <>
   struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, PhysicalDeviceFeatures2>
   {
     enum