Update for Vulkan-Docs 1.2.181

diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index 54fae4f..eb404ce 100644 (file)
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -93,7 +93,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <compare>
 #endif
 
-static_assert( VK_HEADER_VERSION == 180, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 181, "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
@@ -8267,15 +8267,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
-  enum class InstanceCreateFlagBits
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlagBits )
-  {
-    return "(void)";
-  }
-
   enum class InternalAllocationType
   {
     eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE
@@ -8435,15 +8426,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
-  enum class DeviceCreateFlagBits
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlagBits )
-  {
-    return "(void)";
-  }
-
   enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags
   {
     eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
@@ -8660,15 +8642,6 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
-  enum class QueryPoolCreateFlagBits
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlagBits )
-  {
-    return "(void)";
-  }
-
   enum class QueryResultFlagBits : VkQueryResultFlags
   {
     e64               = VK_QUERY_RESULT_64_BIT,
@@ -10153,6 +10126,159 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class InstanceCreateFlagBits
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class DeviceCreateFlagBits
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DeviceCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class MemoryMapFlagBits : VkMemoryMapFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( MemoryMapFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class SemaphoreCreateFlagBits : VkSemaphoreCreateFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class QueryPoolCreateFlagBits
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class BufferViewCreateFlagBits : VkBufferViewCreateFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( BufferViewCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class PipelineColorBlendStateCreateFlagBits : VkPipelineColorBlendStateCreateFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class PipelineDepthStencilStateCreateFlagBits : VkPipelineDepthStencilStateCreateFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class PipelineDynamicStateCreateFlagBits : VkPipelineDynamicStateCreateFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineDynamicStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class PipelineInputAssemblyStateCreateFlagBits : VkPipelineInputAssemblyStateCreateFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineInputAssemblyStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class PipelineMultisampleStateCreateFlagBits : VkPipelineMultisampleStateCreateFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineMultisampleStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class PipelineRasterizationStateCreateFlagBits : VkPipelineRasterizationStateCreateFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class PipelineTessellationStateCreateFlagBits : VkPipelineTessellationStateCreateFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineTessellationStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class PipelineVertexInputStateCreateFlagBits : VkPipelineVertexInputStateCreateFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineVertexInputStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class PipelineViewportStateCreateFlagBits : VkPipelineViewportStateCreateFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineViewportStateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class DescriptorPoolResetFlagBits : VkDescriptorPoolResetFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlagBits )
+  {
+    return "(void)";
+  }
+
   //=== VK_VERSION_1_1 ===
 
   enum class SubgroupFeatureFlagBits : VkSubgroupFeatureFlags
@@ -10512,6 +10638,24 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class CommandPoolTrimFlagBits : VkCommandPoolTrimFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( CommandPoolTrimFlagBits )
+  {
+    return "(void)";
+  }
+
+  enum class DescriptorUpdateTemplateCreateFlagBits : VkDescriptorUpdateTemplateCreateFlags
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateCreateFlagBits )
+  {
+    return "(void)";
+  }
+
   //=== VK_VERSION_1_2 ===
 
   enum class DriverId
@@ -10857,6 +11001,89 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class DisplayModeCreateFlagBitsKHR : VkDisplayModeCreateFlagsKHR
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+
+  enum class DisplaySurfaceCreateFlagBitsKHR : VkDisplaySurfaceCreateFlagsKHR
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+
+#if defined( VK_USE_PLATFORM_XLIB_KHR )
+  //=== VK_KHR_xlib_surface ===
+
+  enum class XlibSurfaceCreateFlagBitsKHR : VkXlibSurfaceCreateFlagsKHR
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( XlibSurfaceCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#if defined( VK_USE_PLATFORM_XCB_KHR )
+  //=== VK_KHR_xcb_surface ===
+
+  enum class XcbSurfaceCreateFlagBitsKHR : VkXcbSurfaceCreateFlagsKHR
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( XcbSurfaceCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
+  //=== VK_KHR_wayland_surface ===
+
+  enum class WaylandSurfaceCreateFlagBitsKHR : VkWaylandSurfaceCreateFlagsKHR
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( WaylandSurfaceCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+  //=== VK_KHR_android_surface ===
+
+  enum class AndroidSurfaceCreateFlagBitsKHR : VkAndroidSurfaceCreateFlagsKHR
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+  //=== VK_KHR_win32_surface ===
+
+  enum class Win32SurfaceCreateFlagBitsKHR : VkWin32SurfaceCreateFlagsKHR
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( Win32SurfaceCreateFlagBitsKHR )
+  {
+    return "(void)";
+  }
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
   //=== VK_EXT_debug_report ===
 
   enum class DebugReportFlagBitsEXT : VkDebugReportFlagsEXT
@@ -11145,6 +11372,24 @@ namespace VULKAN_HPP_NAMESPACE
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
+
+  enum class VideoBeginCodingFlagBitsKHR : VkVideoBeginCodingFlagsKHR
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( VideoBeginCodingFlagBitsKHR )
+  {
+    return "(void)";
+  }
+
+  enum class VideoEndCodingFlagBitsKHR : VkVideoEndCodingFlagsKHR
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( VideoEndCodingFlagBitsKHR )
+  {
+    return "(void)";
+  }
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
@@ -11167,6 +11412,17 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
+  //=== VK_EXT_transform_feedback ===
+
+  enum class PipelineRasterizationStateStreamCreateFlagBitsEXT : VkPipelineRasterizationStateStreamCreateFlagsEXT
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateStreamCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   //=== VK_EXT_video_encode_h264 ===
 
@@ -11295,6 +11551,15 @@ namespace VULKAN_HPP_NAMESPACE
       default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
+
+  enum class VideoDecodeH264CreateFlagBitsEXT : VkVideoDecodeH264CreateFlagsEXT
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264CreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
   //=== VK_AMD_shader_info ===
@@ -11317,6 +11582,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+#if defined( VK_USE_PLATFORM_GGP )
+  //=== VK_GGP_stream_descriptor_surface ===
+
+  enum class StreamDescriptorSurfaceCreateFlagBitsGGP : VkStreamDescriptorSurfaceCreateFlagsGGP
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( StreamDescriptorSurfaceCreateFlagBitsGGP )
+  {
+    return "(void)";
+  }
+#endif /*VK_USE_PLATFORM_GGP*/
+
   //=== VK_NV_external_memory_capabilities ===
 
   enum class ExternalMemoryHandleTypeFlagBitsNV : VkExternalMemoryHandleTypeFlagsNV
@@ -11375,6 +11653,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+#if defined( VK_USE_PLATFORM_VI_NN )
+  //=== VK_NN_vi_surface ===
+
+  enum class ViSurfaceCreateFlagBitsNN : VkViSurfaceCreateFlagsNN
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ViSurfaceCreateFlagBitsNN )
+  {
+    return "(void)";
+  }
+#endif /*VK_USE_PLATFORM_VI_NN*/
+
   //=== VK_EXT_conditional_rendering ===
 
   enum class ConditionalRenderingFlagBitsEXT : VkConditionalRenderingFlagsEXT
@@ -11485,6 +11776,15 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class PipelineViewportSwizzleStateCreateFlagBitsNV : VkPipelineViewportSwizzleStateCreateFlagsNV
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineViewportSwizzleStateCreateFlagBitsNV )
+  {
+    return "(void)";
+  }
+
   //=== VK_EXT_discard_rectangles ===
 
   enum class DiscardRectangleModeEXT
@@ -11503,6 +11803,15 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class PipelineDiscardRectangleStateCreateFlagBitsEXT : VkPipelineDiscardRectangleStateCreateFlagsEXT
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
   //=== VK_EXT_conservative_rasterization ===
 
   enum class ConservativeRasterizationModeEXT
@@ -11523,6 +11832,27 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class
+    PipelineRasterizationConservativeStateCreateFlagBitsEXT : VkPipelineRasterizationConservativeStateCreateFlagsEXT
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationConservativeStateCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
+  //=== VK_EXT_depth_clip_enable ===
+
+  enum class PipelineRasterizationDepthClipStateCreateFlagBitsEXT : VkPipelineRasterizationDepthClipStateCreateFlagsEXT
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationDepthClipStateCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
   //=== VK_KHR_performance_query ===
 
   enum class PerformanceCounterDescriptionFlagBitsKHR : VkPerformanceCounterDescriptionFlagsKHR
@@ -11629,6 +11959,32 @@ namespace VULKAN_HPP_NAMESPACE
     return "(void)";
   }
 
+#if defined( VK_USE_PLATFORM_IOS_MVK )
+  //=== VK_MVK_ios_surface ===
+
+  enum class IOSSurfaceCreateFlagBitsMVK : VkIOSSurfaceCreateFlagsMVK
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( IOSSurfaceCreateFlagBitsMVK )
+  {
+    return "(void)";
+  }
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#if defined( VK_USE_PLATFORM_MACOS_MVK )
+  //=== VK_MVK_macos_surface ===
+
+  enum class MacOSSurfaceCreateFlagBitsMVK : VkMacOSSurfaceCreateFlagsMVK
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( MacOSSurfaceCreateFlagBitsMVK )
+  {
+    return "(void)";
+  }
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
   //=== VK_EXT_debug_utils ===
 
   enum class DebugUtilsMessageSeverityFlagBitsEXT : VkDebugUtilsMessageSeverityFlagsEXT
@@ -11669,6 +12025,24 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class DebugUtilsMessengerCallbackDataFlagBitsEXT : VkDebugUtilsMessengerCallbackDataFlagsEXT
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
+  enum class DebugUtilsMessengerCreateFlagBitsEXT : VkDebugUtilsMessengerCreateFlagsEXT
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
   //=== VK_EXT_blend_operation_advanced ===
 
   enum class BlendOverlapEXT
@@ -11689,6 +12063,17 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  //=== VK_NV_fragment_coverage_to_color ===
+
+  enum class PipelineCoverageToColorStateCreateFlagBitsNV : VkPipelineCoverageToColorStateCreateFlagsNV
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCoverageToColorStateCreateFlagBitsNV )
+  {
+    return "(void)";
+  }
+
   //=== VK_KHR_acceleration_structure ===
 
   enum class AccelerationStructureTypeKHR
@@ -11898,6 +12283,15 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class PipelineCoverageModulationStateCreateFlagBitsNV : VkPipelineCoverageModulationStateCreateFlagsNV
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCoverageModulationStateCreateFlagBitsNV )
+  {
+    return "(void)";
+  }
+
   //=== VK_EXT_validation_cache ===
 
   enum class ValidationCacheHeaderVersionEXT
@@ -11914,6 +12308,15 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class ValidationCacheCreateFlagBitsEXT : VkValidationCacheCreateFlagsEXT
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ValidationCacheCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
   //=== VK_NV_shading_rate_image ===
 
   enum class ShadingRatePaletteEntryNV
@@ -12047,6 +12450,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+  //=== VK_EXT_video_decode_h265 ===
+
+  enum class VideoDecodeH265CreateFlagBitsEXT : VkVideoDecodeH265CreateFlagsEXT
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( VideoDecodeH265CreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
   //=== VK_AMD_memory_overallocation_behavior ===
 
   enum class MemoryOverallocationBehaviorAMD
@@ -12173,6 +12589,32 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+  //=== VK_FUCHSIA_imagepipe_surface ===
+
+  enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA : VkImagePipeSurfaceCreateFlagsFUCHSIA
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ImagePipeSurfaceCreateFlagBitsFUCHSIA )
+  {
+    return "(void)";
+  }
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+  //=== VK_EXT_metal_surface ===
+
+  enum class MetalSurfaceCreateFlagBitsEXT : VkMetalSurfaceCreateFlagsEXT
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( MetalSurfaceCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+
   //=== VK_KHR_fragment_shading_rate ===
 
   enum class FragmentShadingRateCombinerOpKHR
@@ -12362,6 +12804,15 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class PipelineCoverageReductionStateCreateFlagBitsNV : VkPipelineCoverageReductionStateCreateFlagsNV
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( PipelineCoverageReductionStateCreateFlagBitsNV )
+  {
+    return "(void)";
+  }
+
   //=== VK_EXT_provoking_vertex ===
 
   enum class ProvokingVertexModeEXT
@@ -12404,6 +12855,17 @@ namespace VULKAN_HPP_NAMESPACE
   }
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
+  //=== VK_EXT_headless_surface ===
+
+  enum class HeadlessSurfaceCreateFlagBitsEXT : VkHeadlessSurfaceCreateFlagsEXT
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( HeadlessSurfaceCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
   //=== VK_EXT_line_rasterization ===
 
   enum class LineRasterizationModeEXT
@@ -12534,6 +12996,15 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+  enum class DeviceMemoryReportFlagBitsEXT : VkDeviceMemoryReportFlagsEXT
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DeviceMemoryReportFlagBitsEXT )
+  {
+    return "(void)";
+  }
+
   //=== VK_EXT_private_data ===
 
   enum class PrivateDataSlotCreateFlagBitsEXT : VkPrivateDataSlotCreateFlagsEXT
@@ -12872,6 +13343,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
+  //=== VK_EXT_directfb_surface ===
+
+  enum class DirectFBSurfaceCreateFlagBitsEXT : VkDirectFBSurfaceCreateFlagsEXT
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( DirectFBSurfaceCreateFlagBitsEXT )
+  {
+    return "(void)";
+  }
+#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
   //=== VK_KHR_ray_tracing_pipeline ===
 
   enum class RayTracingShaderGroupTypeKHR
@@ -12913,6 +13397,19 @@ namespace VULKAN_HPP_NAMESPACE
     }
   }
 
+#if defined( VK_USE_PLATFORM_SCREEN_QNX )
+  //=== VK_QNX_screen_surface ===
+
+  enum class ScreenSurfaceCreateFlagBitsQNX : VkScreenSurfaceCreateFlagsQNX
+  {
+  };
+
+  VULKAN_HPP_INLINE std::string to_string( ScreenSurfaceCreateFlagBitsQNX )
+  {
+    return "(void)";
+  }
+#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+
   template <ObjectType value>
   struct cpp_type
   {};
@@ -13691,15 +14188,6 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
-  enum class MemoryMapFlagBits : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( MemoryMapFlagBits )
-  {
-    return "(void)";
-  }
-
   using MemoryMapFlags = Flags<MemoryMapFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags )
@@ -13920,15 +14408,6 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
-  enum class SemaphoreCreateFlagBits : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlagBits )
-  {
-    return "(void)";
-  }
-
   using SemaphoreCreateFlags = Flags<SemaphoreCreateFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( SemaphoreCreateFlags )
@@ -14286,15 +14765,6 @@ 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 )
@@ -14505,15 +14975,6 @@ 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 )
@@ -14618,15 +15079,6 @@ 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 )
@@ -14634,15 +15086,6 @@ 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 )
@@ -14650,15 +15093,6 @@ 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 )
@@ -14666,15 +15100,6 @@ 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 )
@@ -14682,15 +15107,6 @@ 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 )
@@ -14698,15 +15114,6 @@ 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 )
@@ -14763,15 +15170,6 @@ 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 )
@@ -14779,15 +15177,6 @@ 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 )
@@ -14795,15 +15184,6 @@ 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 )
@@ -14989,15 +15369,6 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
-  enum class DescriptorPoolResetFlagBits : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlagBits )
-  {
-    return "(void)";
-  }
-
   using DescriptorPoolResetFlags = Flags<DescriptorPoolResetFlagBits>;
 
   VULKAN_HPP_INLINE std::string to_string( DescriptorPoolResetFlags )
@@ -15883,15 +16254,6 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
-  enum class CommandPoolTrimFlagBits : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( CommandPoolTrimFlagBits )
-  {
-    return "(void)";
-  }
-
   using CommandPoolTrimFlags = Flags<CommandPoolTrimFlagBits>;
 
   using CommandPoolTrimFlagsKHR = CommandPoolTrimFlags;
@@ -15901,15 +16263,6 @@ namespace VULKAN_HPP_NAMESPACE
     return "{}";
   }
 
-  enum class DescriptorUpdateTemplateCreateFlagBits : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( DescriptorUpdateTemplateCreateFlagBits )
-  {
-    return "(void)";
-  }
-
   using DescriptorUpdateTemplateCreateFlags = Flags<DescriptorUpdateTemplateCreateFlagBits>;
 
   using DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags;
@@ -16710,15 +17063,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   //=== VK_KHR_display ===
 
-  enum class DisplayModeCreateFlagBitsKHR : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagBitsKHR )
-  {
-    return "(void)";
-  }
-
   using DisplayModeCreateFlagsKHR = Flags<DisplayModeCreateFlagBitsKHR>;
 
   VULKAN_HPP_INLINE std::string to_string( DisplayModeCreateFlagsKHR )
@@ -16780,15 +17124,6 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
-  enum class DisplaySurfaceCreateFlagBitsKHR : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagBitsKHR )
-  {
-    return "(void)";
-  }
-
   using DisplaySurfaceCreateFlagsKHR = Flags<DisplaySurfaceCreateFlagBitsKHR>;
 
   VULKAN_HPP_INLINE std::string to_string( DisplaySurfaceCreateFlagsKHR )
@@ -16868,15 +17203,6 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_XLIB_KHR )
   //=== VK_KHR_xlib_surface ===
 
-  enum class XlibSurfaceCreateFlagBitsKHR : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( XlibSurfaceCreateFlagBitsKHR )
-  {
-    return "(void)";
-  }
-
   using XlibSurfaceCreateFlagsKHR = Flags<XlibSurfaceCreateFlagBitsKHR>;
 
   VULKAN_HPP_INLINE std::string to_string( XlibSurfaceCreateFlagsKHR )
@@ -16888,15 +17214,6 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_XCB_KHR )
   //=== VK_KHR_xcb_surface ===
 
-  enum class XcbSurfaceCreateFlagBitsKHR : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( XcbSurfaceCreateFlagBitsKHR )
-  {
-    return "(void)";
-  }
-
   using XcbSurfaceCreateFlagsKHR = Flags<XcbSurfaceCreateFlagBitsKHR>;
 
   VULKAN_HPP_INLINE std::string to_string( XcbSurfaceCreateFlagsKHR )
@@ -16908,15 +17225,6 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
   //=== VK_KHR_wayland_surface ===
 
-  enum class WaylandSurfaceCreateFlagBitsKHR : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( WaylandSurfaceCreateFlagBitsKHR )
-  {
-    return "(void)";
-  }
-
   using WaylandSurfaceCreateFlagsKHR = Flags<WaylandSurfaceCreateFlagBitsKHR>;
 
   VULKAN_HPP_INLINE std::string to_string( WaylandSurfaceCreateFlagsKHR )
@@ -16928,15 +17236,6 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
   //=== VK_KHR_android_surface ===
 
-  enum class AndroidSurfaceCreateFlagBitsKHR : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagBitsKHR )
-  {
-    return "(void)";
-  }
-
   using AndroidSurfaceCreateFlagsKHR = Flags<AndroidSurfaceCreateFlagBitsKHR>;
 
   VULKAN_HPP_INLINE std::string to_string( AndroidSurfaceCreateFlagsKHR )
@@ -16948,15 +17247,6 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   //=== VK_KHR_win32_surface ===
 
-  enum class Win32SurfaceCreateFlagBitsKHR : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( Win32SurfaceCreateFlagBitsKHR )
-  {
-    return "(void)";
-  }
-
   using Win32SurfaceCreateFlagsKHR = Flags<Win32SurfaceCreateFlagBitsKHR>;
 
   VULKAN_HPP_INLINE std::string to_string( Win32SurfaceCreateFlagsKHR )
@@ -17290,15 +17580,6 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
-  enum class VideoBeginCodingFlagBitsKHR : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( VideoBeginCodingFlagBitsKHR )
-  {
-    return "(void)";
-  }
-
   using VideoBeginCodingFlagsKHR = Flags<VideoBeginCodingFlagBitsKHR>;
 
   VULKAN_HPP_INLINE std::string to_string( VideoBeginCodingFlagsKHR )
@@ -17306,15 +17587,6 @@ namespace VULKAN_HPP_NAMESPACE
     return "{}";
   }
 
-  enum class VideoEndCodingFlagBitsKHR : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( VideoEndCodingFlagBitsKHR )
-  {
-    return "(void)";
-  }
-
   using VideoEndCodingFlagsKHR = Flags<VideoEndCodingFlagBitsKHR>;
 
   VULKAN_HPP_INLINE std::string to_string( VideoEndCodingFlagsKHR )
@@ -17474,15 +17746,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   //=== VK_EXT_transform_feedback ===
 
-  enum class PipelineRasterizationStateStreamCreateFlagBitsEXT : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateStreamCreateFlagBitsEXT )
-  {
-    return "(void)";
-  }
-
   using PipelineRasterizationStateStreamCreateFlagsEXT = Flags<PipelineRasterizationStateStreamCreateFlagBitsEXT>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationStateStreamCreateFlagsEXT )
@@ -17775,15 +18038,6 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
-  enum class VideoDecodeH264CreateFlagBitsEXT : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264CreateFlagBitsEXT )
-  {
-    return "(void)";
-  }
-
   using VideoDecodeH264CreateFlagsEXT = Flags<VideoDecodeH264CreateFlagBitsEXT>;
 
   VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264CreateFlagsEXT )
@@ -17795,15 +18049,6 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_GGP )
   //=== VK_GGP_stream_descriptor_surface ===
 
-  enum class StreamDescriptorSurfaceCreateFlagBitsGGP : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( StreamDescriptorSurfaceCreateFlagBitsGGP )
-  {
-    return "(void)";
-  }
-
   using StreamDescriptorSurfaceCreateFlagsGGP = Flags<StreamDescriptorSurfaceCreateFlagBitsGGP>;
 
   VULKAN_HPP_INLINE std::string to_string( StreamDescriptorSurfaceCreateFlagsGGP )
@@ -17924,15 +18169,6 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_VI_NN )
   //=== VK_NN_vi_surface ===
 
-  enum class ViSurfaceCreateFlagBitsNN : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( ViSurfaceCreateFlagBitsNN )
-  {
-    return "(void)";
-  }
-
   using ViSurfaceCreateFlagsNN = Flags<ViSurfaceCreateFlagBitsNN>;
 
   VULKAN_HPP_INLINE std::string to_string( ViSurfaceCreateFlagsNN )
@@ -18039,15 +18275,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   //=== VK_NV_viewport_swizzle ===
 
-  enum class PipelineViewportSwizzleStateCreateFlagBitsNV : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineViewportSwizzleStateCreateFlagBitsNV )
-  {
-    return "(void)";
-  }
-
   using PipelineViewportSwizzleStateCreateFlagsNV = Flags<PipelineViewportSwizzleStateCreateFlagBitsNV>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineViewportSwizzleStateCreateFlagsNV )
@@ -18057,15 +18284,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   //=== VK_EXT_discard_rectangles ===
 
-  enum class PipelineDiscardRectangleStateCreateFlagBitsEXT : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagBitsEXT )
-  {
-    return "(void)";
-  }
-
   using PipelineDiscardRectangleStateCreateFlagsEXT = Flags<PipelineDiscardRectangleStateCreateFlagBitsEXT>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineDiscardRectangleStateCreateFlagsEXT )
@@ -18075,15 +18293,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   //=== VK_EXT_conservative_rasterization ===
 
-  enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationConservativeStateCreateFlagBitsEXT )
-  {
-    return "(void)";
-  }
-
   using PipelineRasterizationConservativeStateCreateFlagsEXT =
     Flags<PipelineRasterizationConservativeStateCreateFlagBitsEXT>;
 
@@ -18094,15 +18303,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   //=== VK_EXT_depth_clip_enable ===
 
-  enum class PipelineRasterizationDepthClipStateCreateFlagBitsEXT : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationDepthClipStateCreateFlagBitsEXT )
-  {
-    return "(void)";
-  }
-
   using PipelineRasterizationDepthClipStateCreateFlagsEXT = Flags<PipelineRasterizationDepthClipStateCreateFlagBitsEXT>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineRasterizationDepthClipStateCreateFlagsEXT )
@@ -18171,15 +18371,6 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_IOS_MVK )
   //=== VK_MVK_ios_surface ===
 
-  enum class IOSSurfaceCreateFlagBitsMVK : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( IOSSurfaceCreateFlagBitsMVK )
-  {
-    return "(void)";
-  }
-
   using IOSSurfaceCreateFlagsMVK = Flags<IOSSurfaceCreateFlagBitsMVK>;
 
   VULKAN_HPP_INLINE std::string to_string( IOSSurfaceCreateFlagsMVK )
@@ -18191,15 +18382,6 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_MACOS_MVK )
   //=== VK_MVK_macos_surface ===
 
-  enum class MacOSSurfaceCreateFlagBitsMVK : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( MacOSSurfaceCreateFlagBitsMVK )
-  {
-    return "(void)";
-  }
-
   using MacOSSurfaceCreateFlagsMVK = Flags<MacOSSurfaceCreateFlagBitsMVK>;
 
   VULKAN_HPP_INLINE std::string to_string( MacOSSurfaceCreateFlagsMVK )
@@ -18317,15 +18499,6 @@ namespace VULKAN_HPP_NAMESPACE
     return "{ " + result.substr( 0, result.size() - 3 ) + " }";
   }
 
-  enum class DebugUtilsMessengerCallbackDataFlagBitsEXT : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagBitsEXT )
-  {
-    return "(void)";
-  }
-
   using DebugUtilsMessengerCallbackDataFlagsEXT = Flags<DebugUtilsMessengerCallbackDataFlagBitsEXT>;
 
   VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCallbackDataFlagsEXT )
@@ -18333,15 +18506,6 @@ namespace VULKAN_HPP_NAMESPACE
     return "{}";
   }
 
-  enum class DebugUtilsMessengerCreateFlagBitsEXT : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagBitsEXT )
-  {
-    return "(void)";
-  }
-
   using DebugUtilsMessengerCreateFlagsEXT = Flags<DebugUtilsMessengerCreateFlagBitsEXT>;
 
   VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessengerCreateFlagsEXT )
@@ -18351,15 +18515,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   //=== VK_NV_fragment_coverage_to_color ===
 
-  enum class PipelineCoverageToColorStateCreateFlagBitsNV : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineCoverageToColorStateCreateFlagBitsNV )
-  {
-    return "(void)";
-  }
-
   using PipelineCoverageToColorStateCreateFlagsNV = Flags<PipelineCoverageToColorStateCreateFlagBitsNV>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineCoverageToColorStateCreateFlagsNV )
@@ -18583,15 +18738,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   //=== VK_NV_framebuffer_mixed_samples ===
 
-  enum class PipelineCoverageModulationStateCreateFlagBitsNV : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineCoverageModulationStateCreateFlagBitsNV )
-  {
-    return "(void)";
-  }
-
   using PipelineCoverageModulationStateCreateFlagsNV = Flags<PipelineCoverageModulationStateCreateFlagBitsNV>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineCoverageModulationStateCreateFlagsNV )
@@ -18601,15 +18747,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   //=== VK_EXT_validation_cache ===
 
-  enum class ValidationCacheCreateFlagBitsEXT : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( ValidationCacheCreateFlagBitsEXT )
-  {
-    return "(void)";
-  }
-
   using ValidationCacheCreateFlagsEXT = Flags<ValidationCacheCreateFlagBitsEXT>;
 
   VULKAN_HPP_INLINE std::string to_string( ValidationCacheCreateFlagsEXT )
@@ -18629,15 +18766,6 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
   //=== VK_EXT_video_decode_h265 ===
 
-  enum class VideoDecodeH265CreateFlagBitsEXT : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( VideoDecodeH265CreateFlagBitsEXT )
-  {
-    return "(void)";
-  }
-
   using VideoDecodeH265CreateFlagsEXT = Flags<VideoDecodeH265CreateFlagBitsEXT>;
 
   VULKAN_HPP_INLINE std::string to_string( VideoDecodeH265CreateFlagsEXT )
@@ -18703,15 +18831,6 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_FUCHSIA )
   //=== VK_FUCHSIA_imagepipe_surface ===
 
-  enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( ImagePipeSurfaceCreateFlagBitsFUCHSIA )
-  {
-    return "(void)";
-  }
-
   using ImagePipeSurfaceCreateFlagsFUCHSIA = Flags<ImagePipeSurfaceCreateFlagBitsFUCHSIA>;
 
   VULKAN_HPP_INLINE std::string to_string( ImagePipeSurfaceCreateFlagsFUCHSIA )
@@ -18723,15 +18842,6 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_METAL_EXT )
   //=== VK_EXT_metal_surface ===
 
-  enum class MetalSurfaceCreateFlagBitsEXT : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( MetalSurfaceCreateFlagBitsEXT )
-  {
-    return "(void)";
-  }
-
   using MetalSurfaceCreateFlagsEXT = Flags<MetalSurfaceCreateFlagBitsEXT>;
 
   VULKAN_HPP_INLINE std::string to_string( MetalSurfaceCreateFlagsEXT )
@@ -18814,15 +18924,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   //=== VK_NV_coverage_reduction_mode ===
 
-  enum class PipelineCoverageReductionStateCreateFlagBitsNV : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( PipelineCoverageReductionStateCreateFlagBitsNV )
-  {
-    return "(void)";
-  }
-
   using PipelineCoverageReductionStateCreateFlagsNV = Flags<PipelineCoverageReductionStateCreateFlagBitsNV>;
 
   VULKAN_HPP_INLINE std::string to_string( PipelineCoverageReductionStateCreateFlagsNV )
@@ -18832,15 +18933,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   //=== VK_EXT_headless_surface ===
 
-  enum class HeadlessSurfaceCreateFlagBitsEXT : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( HeadlessSurfaceCreateFlagBitsEXT )
-  {
-    return "(void)";
-  }
-
   using HeadlessSurfaceCreateFlagsEXT = Flags<HeadlessSurfaceCreateFlagBitsEXT>;
 
   VULKAN_HPP_INLINE std::string to_string( HeadlessSurfaceCreateFlagsEXT )
@@ -18950,15 +19042,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   //=== VK_EXT_device_memory_report ===
 
-  enum class DeviceMemoryReportFlagBitsEXT : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( DeviceMemoryReportFlagBitsEXT )
-  {
-    return "(void)";
-  }
-
   using DeviceMemoryReportFlagsEXT = Flags<DeviceMemoryReportFlagBitsEXT>;
 
   VULKAN_HPP_INLINE std::string to_string( DeviceMemoryReportFlagsEXT )
@@ -19516,15 +19599,6 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
   //=== VK_EXT_directfb_surface ===
 
-  enum class DirectFBSurfaceCreateFlagBitsEXT : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( DirectFBSurfaceCreateFlagBitsEXT )
-  {
-    return "(void)";
-  }
-
   using DirectFBSurfaceCreateFlagsEXT = Flags<DirectFBSurfaceCreateFlagBitsEXT>;
 
   VULKAN_HPP_INLINE std::string to_string( DirectFBSurfaceCreateFlagsEXT )
@@ -19536,15 +19610,6 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
   //=== VK_QNX_screen_surface ===
 
-  enum class ScreenSurfaceCreateFlagBitsQNX : VkFlags
-  {
-  };
-
-  VULKAN_HPP_INLINE std::string to_string( ScreenSurfaceCreateFlagBitsQNX )
-  {
-    return "(void)";
-  }
-
   using ScreenSurfaceCreateFlagsQNX = Flags<ScreenSurfaceCreateFlagBitsQNX>;
 
   VULKAN_HPP_INLINE std::string to_string( ScreenSurfaceCreateFlagsQNX )
@@ -104101,8 +104166,9 @@ namespace VULKAN_HPP_NAMESPACE
                                                                   reinterpret_cast<void *>( data.data() ),
                                                                   static_cast<VkDeviceSize>( stride ),
                                                                   static_cast<VkQueryResultFlags>( flags ) ) );
-    return createResultValue(
-      result, VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } );
+    return createResultValue( result,
+                              VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults",
+                              { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
   }
 
   template <typename T, typename Allocator, typename Dispatch>

diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h
index 2e9ef74..ac66183 100644 (file)
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@@ -72,7 +72,7 @@ extern "C" {
 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
 
 // Version of this file
-#define VK_HEADER_VERSION 180
+#define VK_HEADER_VERSION 181
 
 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION)

diff --git a/registry/validusage.json b/registry/validusage.json
index f9864c0..e80f06e 100644 (file)
--- a/registry/validusage.json
+++ b/registry/validusage.json
@@ -1,9 +1,9 @@
 {
   "version info": {
     "schema version": 2,
-    "api version": "1.2.180",
-    "comment": "from git branch: github-main commit: b4e8cd820b2487bc892b391fb26b49501473a6a6",
-    "date": "2021-06-06 12:24:39Z"
+    "api version": "1.2.181",
+    "comment": "from git branch: github-main commit: ee9ed265a687fc31837081c6594530c6979235a4",
+    "date": "2021-06-14 04:12:47Z"
   },
   "validation": {
     "vkGetInstanceProcAddr": {
@@ -59,6 +59,18 @@
       ]
     },
     "VkInstanceCreateInfo": {
+      "(VK_EXT_debug_report,VK_EXT_debug_utils)+(VK_EXT_debug_report)": [
+        {
+          "vuid": "VUID-VkInstanceCreateInfo-pNext-04925",
+          "text": " If the <code>pNext</code> chain of <code>VkInstanceCreateInfo</code> includes a <code>VkDebugReportCallbackCreateInfoEXT</code> structure, the list of enabled extensions in <code>ppEnabledExtensionNames</code> <strong class=\"purple\">must</strong> contain VK_EXT_debug_report."
+        }
+      ],
+      "(VK_EXT_debug_report,VK_EXT_debug_utils)+(VK_EXT_debug_utils)": [
+        {
+          "vuid": "VUID-VkInstanceCreateInfo-pNext-04926",
+          "text": " If the <code>pNext</code> chain of <code>VkInstanceCreateInfo</code> includes a <code>VkDebugUtilsMessengerCreateInfoEXT</code> structure, the list of enabled extensions in <code>ppEnabledExtensionNames</code> <strong class=\"purple\">must</strong> contain VK_EXT_debug_utils."
+        }
+      ],
       "core": [
         {
           "vuid": "VUID-VkInstanceCreateInfo-sType-sType",
@@ -572,17 +584,17 @@
       "(VK_EXT_shader_image_atomic_int64)": [
         {
           "vuid": "VUID-VkDeviceCreateInfo-None-04896",
-          "text": " If <a href=\"#features-sparseImageInt64Atomics\">sparseImageInt64Atomics</a> is enabled, <a href=\"#features-shaderImageInt64Atomics\">shaderImageInt64Atomics</a> <strong class=\"purple\">must</strong> be enabled"
+          "text": " If <a href=\"#features-sparseImageInt64Atomics\"><code>sparseImageInt64Atomics</code></a> is enabled, <a href=\"#features-shaderImageInt64Atomics\"><code>shaderImageInt64Atomics</code></a> <strong class=\"purple\">must</strong> be enabled"
         }
       ],
       "(VK_EXT_shader_atomic_float)": [
         {
           "vuid": "VUID-VkDeviceCreateInfo-None-04897",
-          "text": " If <a href=\"#features-sparseImageFloat32Atomics\">sparseImageFloat32Atomics</a> is enabled, <a href=\"#features-shaderImageFloat32Atomics\">shaderImageFloat32Atomics</a> <strong class=\"purple\">must</strong> be enabled"
+          "text": " If <a href=\"#features-sparseImageFloat32Atomics\"><code>sparseImageFloat32Atomics</code></a> is enabled, <a href=\"#features-shaderImageFloat32Atomics\"><code>shaderImageFloat32Atomics</code></a> <strong class=\"purple\">must</strong> be enabled"
         },
         {
           "vuid": "VUID-VkDeviceCreateInfo-None-04898",
-          "text": " If <a href=\"#features-sparseImageFloat32AtomicAdd\">sparseImageFloat32AtomicAdd</a> is enabled, <a href=\"#features-shaderImageFloat32AtomicAdd\">shaderImageFloat32AtomicAdd</a> <strong class=\"purple\">must</strong> be enabled"
+          "text": " If <a href=\"#features-sparseImageFloat32AtomicAdd\"><code>sparseImageFloat32AtomicAdd</code></a> is enabled, <a href=\"#features-shaderImageFloat32AtomicAdd\"><code>shaderImageFloat32AtomicAdd</code></a> <strong class=\"purple\">must</strong> be enabled"
         }
       ],
       "core": [

diff --git a/registry/vk.xml b/registry/vk.xml
index 98dc2c0..a1844b2 100644 (file)
--- a/registry/vk.xml
+++ b/registry/vk.xml
@@ -155,7 +155,7 @@ branch of the member gitlab server.
         <type category="define" requires="VK_MAKE_API_VERSION">// Vulkan 1.2 version number
 #define <name>VK_API_VERSION_1_2</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 2, 0)// Patch version should always be set to 0</type>
         <type category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 180</type>
+#define <name>VK_HEADER_VERSION</name> 181</type>
         <type category="define" requires="VK_HEADER_VERSION">// Complete version of this file
 #define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 2, VK_HEADER_VERSION)</type>
 
@@ -545,6 +545,7 @@ typedef void <name>CAMetalLayer</name>;
         <type name="VkDependencyFlagBits" category="enum"/>
         <type name="VkObjectType" category="enum"/>
         <type name="VkEventCreateFlagBits" category="enum"/>
+        <type name="VkPipelineLayoutCreateFlagBits" category="enum"/>
             <comment>When VkSemaphoreCreateFlagBits is first extended, need to add a type enum tag for it here</comment>
 
         <comment>Extensions</comment>
@@ -7365,11 +7366,12 @@ typedef void <name>CAMetalLayer</name>;
     </enums>
     <enums name="VkEventCreateFlagBits" type="bitmask">
     </enums>
+    <enums name="VkPipelineLayoutCreateFlagBits" type="bitmask">
+    </enums>
     <enums name="VkProvokingVertexModeEXT" type="enum">
         <enum value="0"     name="VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT"/>
         <enum value="1"     name="VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT"/>
     </enums>
-
     <enums name="VkVideoCodecOperationFlagBitsKHR" type="bitmask">
         <enum value="0"     name="VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR"/>
     </enums>
@@ -12066,6 +12068,12 @@ typedef void <name>CAMetalLayer</name>;
                 <type name="VkVideoEncodeH264ProfileEXT"/>
             </require>
         </extension>
+        <extension name="VK_EXT_video_encode_h265" number="40" type="device" requires="VK_KHR_video_encode_queue" author="KHR" contact="Ahmed Abdelkhalek @aabdelkh" supported="disabled">
+            <require>
+                <enum value="0"                                              name="VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION"/>
+                <enum value="&quot;VK_EXT_video_encode_h265&quot;"           name="VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME"/>
+            </require>
+        </extension>
         <extension name="VK_EXT_video_decode_h264" number="41" type="device" requires="VK_KHR_video_decode_queue" author="KHR" contact="peter.fang@amd.com" provisional="true" platform="provisional" supported="vulkan">
             <require>
                 <enum value="1"                                              name="VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION"/>
@@ -16030,6 +16038,9 @@ typedef void <name>CAMetalLayer</name>;
             <require>
                 <enum value="0"                                         name="VK_HUAWEI_EXTENSION_371_SPEC_VERSION"/>
                 <enum value="&quot;VK_HUAWEI_extension_371&quot;"         name="VK_HUAWEI_EXTENSION_371_EXTENSION_NAME"/>
+                <enum bitpos="39" extends="VkAccessFlagBits2KHR"          name="VK_ACCESS_2_RESERVED_39_BIT_HUAWEI"/>
+                <enum bitpos="18" extends="VkImageUsageFlagBits"             name="VK_IMAGE_USAGE_RESERVED_18_BIT_HUAWEI"/>
+                <enum bitpos="40" extends="VkPipelineStageFlagBits2KHR"     name="VK_PIPELINE_STAGE_2_RESERVED_40_BIT_HUAWEI"/>
             </require>
         </extension>
         <extension name="VK_NV_extension_372" number="372" author="NV" contact="Carsten Rohde @crohde" supported="disabled">
@@ -16307,6 +16318,36 @@ typedef void <name>CAMetalLayer</name>;
                 <enum value="&quot;VK_GGP_extension_411&quot;"          name="VK_GGP_EXTENSION_411_EXTENSION_NAME"/>
             </require>
         </extension>
+        <extension name="VK_NV_extension_412" number="412" author="NV" contact="Piers Daniell @pdaniell-nv" supported="disabled">
+            <require>
+                <enum value="0"                                         name="VK_NV_EXTENSION_412_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_extension_412&quot;"           name="VK_NV_EXTENSION_412_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_NV_extension_413" number="413" author="NV" contact="Piers Daniell @pdaniell-nv" supported="disabled">
+            <require>
+                <enum value="0"                                         name="VK_NV_EXTENSION_413_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_extension_413&quot;"           name="VK_NV_EXTENSION_413_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_NV_extension_414" number="414" author="NV" contact="Piers Daniell @pdaniell-nv" supported="disabled">
+            <require>
+                <enum value="0"                                         name="VK_NV_EXTENSION_414_SPEC_VERSION"/>
+                <enum value="&quot;VK_NV_extension_414&quot;"           name="VK_NV_EXTENSION_414_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_HUAWEI_extension_415" number="415" author="HUAWEI" contact="Hueilong Wang @wyvernathuawei" supported="disabled">
+            <require>
+                <enum value="0"                                         name="VK_HUAWEI_EXTENSION_415_SPEC_VERSION"/>
+                <enum value="&quot;VK_HUAWEI_extension_415&quot;"         name="VK_HUAWEI_EXTENSION_415_EXTENSION_NAME"/>
+            </require>
+        </extension>
+        <extension name="VK_ARM_extension_416" number="416" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
+            <require>
+                <enum value="0"                                         name="VK_ARM_EXTENSION_416_SPEC_VERSION"/>
+                <enum value="&quot;VK_ARM_extension_416&quot;"          name="VK_ARM_EXTENSION_416_EXTENSION_NAME"/>
+            </require>
+        </extension>
     </extensions>
     <spirvextensions comment="SPIR-V Extensions allowed in Vulkan and what is required to use it">
         <spirvextension name="SPV_KHR_variable_pointers">