Split vk.rs into multiple files (#286)

* Allow the generator to be run from project root dir

* Split vk.rs into multiple files

* Breakup and remove generated vk/prelude.rs

Generator changes:

- No longer convert current dir to a string when checking if the
  path ends with 'generator'
- Pass the 'ash/src' dir instead of the 'vk.rs' path

Generated and generated output changes:

- The majority of prelude.rs has been moved to macros.rs
- The pointer chain and Handle are now included in vk.rs
- Platform types has been moved to its own file.

ash/src/vk/aliases.rs

@@ -0,0 +1,171 @@
+use crate::vk::bitflags::*;
+use crate::vk::definitions::*;
+use crate::vk::enums::*;
+pub type GeometryFlagsNV = GeometryFlagsKHR;
+pub type GeometryInstanceFlagsNV = GeometryInstanceFlagsKHR;
+pub type BuildAccelerationStructureFlagsNV = BuildAccelerationStructureFlagsKHR;
+pub type DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags;
+pub type SemaphoreWaitFlagsKHR = SemaphoreWaitFlags;
+pub type PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags;
+pub type MemoryAllocateFlagsKHR = MemoryAllocateFlags;
+pub type CommandPoolTrimFlagsKHR = CommandPoolTrimFlags;
+pub type ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags;
+pub type ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags;
+pub type ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags;
+pub type ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags;
+pub type SemaphoreImportFlagsKHR = SemaphoreImportFlags;
+pub type ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags;
+pub type ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags;
+pub type FenceImportFlagsKHR = FenceImportFlags;
+pub type DescriptorBindingFlagsEXT = DescriptorBindingFlags;
+pub type ResolveModeFlagsKHR = ResolveModeFlags;
+pub type DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
+pub type SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
+pub type AccelerationStructureNV = AccelerationStructureKHR;
+pub type DescriptorUpdateTemplateTypeKHR = DescriptorUpdateTemplateType;
+pub type PointClippingBehaviorKHR = PointClippingBehavior;
+pub type SemaphoreTypeKHR = SemaphoreType;
+pub type CopyAccelerationStructureModeNV = CopyAccelerationStructureModeKHR;
+pub type AccelerationStructureTypeNV = AccelerationStructureTypeKHR;
+pub type GeometryTypeNV = GeometryTypeKHR;
+pub type RayTracingShaderGroupTypeNV = RayTracingShaderGroupTypeKHR;
+pub type AccelerationStructureMemoryRequirementsTypeNV =
+    AccelerationStructureMemoryRequirementsTypeKHR;
+pub type TessellationDomainOriginKHR = TessellationDomainOrigin;
+pub type SamplerYcbcrModelConversionKHR = SamplerYcbcrModelConversion;
+pub type SamplerYcbcrRangeKHR = SamplerYcbcrRange;
+pub type ChromaLocationKHR = ChromaLocation;
+pub type SamplerReductionModeEXT = SamplerReductionMode;
+pub type ShaderFloatControlsIndependenceKHR = ShaderFloatControlsIndependence;
+pub type DriverIdKHR = DriverId;
+pub type PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
+pub type PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
+pub type FormatProperties2KHR = FormatProperties2;
+pub type ImageFormatProperties2KHR = ImageFormatProperties2;
+pub type PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
+pub type QueueFamilyProperties2KHR = QueueFamilyProperties2;
+pub type PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
+pub type SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
+pub type PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
+pub type ConformanceVersionKHR = ConformanceVersion;
+pub type PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
+pub type PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
+pub type PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
+pub type PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures;
+pub type ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
+pub type PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
+pub type ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
+pub type PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
+pub type ExternalBufferPropertiesKHR = ExternalBufferProperties;
+pub type PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
+pub type ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
+pub type ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
+pub type ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
+pub type PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
+pub type ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
+pub type ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
+pub type PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
+pub type ExternalFencePropertiesKHR = ExternalFenceProperties;
+pub type ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
+pub type PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
+pub type PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
+pub type RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
+pub type PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
+pub type MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
+pub type BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
+pub type BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
+pub type BindImageMemoryInfoKHR = BindImageMemoryInfo;
+pub type BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
+pub type DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
+pub type DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
+pub type DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
+pub type DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
+pub type DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
+pub type DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
+pub type DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
+pub type InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
+pub type RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
+pub type PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
+pub type PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR =
+    PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
+pub type BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
+pub type ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
+pub type ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
+pub type MemoryRequirements2KHR = MemoryRequirements2;
+pub type SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
+pub type PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
+pub type MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
+pub type MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
+pub type ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
+pub type PipelineTessellationDomainOriginStateCreateInfoKHR =
+    PipelineTessellationDomainOriginStateCreateInfo;
+pub type SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
+pub type SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
+pub type BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
+pub type ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
+pub type PhysicalDeviceSamplerYcbcrConversionFeaturesKHR =
+    PhysicalDeviceSamplerYcbcrConversionFeatures;
+pub type SamplerYcbcrConversionImageFormatPropertiesKHR =
+    SamplerYcbcrConversionImageFormatProperties;
+pub type PhysicalDeviceSamplerFilterMinmaxPropertiesEXT =
+    PhysicalDeviceSamplerFilterMinmaxProperties;
+pub type SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
+pub type ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
+pub type PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
+pub type DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
+pub type PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
+pub type PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
+pub type PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
+pub type PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
+pub type PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
+pub type PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
+pub type PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
+pub type DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
+pub type DescriptorSetVariableDescriptorCountAllocateInfoEXT =
+    DescriptorSetVariableDescriptorCountAllocateInfo;
+pub type DescriptorSetVariableDescriptorCountLayoutSupportEXT =
+    DescriptorSetVariableDescriptorCountLayoutSupport;
+pub type AttachmentDescription2KHR = AttachmentDescription2;
+pub type AttachmentReference2KHR = AttachmentReference2;
+pub type SubpassDescription2KHR = SubpassDescription2;
+pub type SubpassDependency2KHR = SubpassDependency2;
+pub type RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
+pub type SubpassBeginInfoKHR = SubpassBeginInfo;
+pub type SubpassEndInfoKHR = SubpassEndInfo;
+pub type PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
+pub type PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
+pub type SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
+pub type TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
+pub type SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
+pub type SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
+pub type PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
+pub type PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
+pub type PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
+pub type PhysicalDeviceDepthStencilResolvePropertiesKHR =
+    PhysicalDeviceDepthStencilResolveProperties;
+pub type SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
+pub type BindAccelerationStructureMemoryInfoNV = BindAccelerationStructureMemoryInfoKHR;
+pub type WriteDescriptorSetAccelerationStructureNV = WriteDescriptorSetAccelerationStructureKHR;
+pub type ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
+pub type PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
+pub type PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR =
+    PhysicalDeviceUniformBufferStandardLayoutFeatures;
+pub type PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
+pub type PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
+pub type BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
+pub type BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
+pub type BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
+pub type PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
+pub type FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
+pub type FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
+pub type RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
+pub type QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
+pub type PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR =
+    PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
+pub type AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
+pub type AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
+pub type MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
+pub type DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
+pub type AabbPositionsNV = AabbPositionsKHR;
+pub type TransformMatrixNV = TransformMatrixKHR;
+pub type AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;

ash/src/vk/bitflags.rs

@@ -0,0 +1,969 @@
+use crate::vk::definitions::*;
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCacheCreateFlagBits.html>"]
+pub struct PipelineCacheCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(PipelineCacheCreateFlags, 0b0, Flags);
+impl PipelineCacheCreateFlags {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCullModeFlagBits.html>"]
+pub struct CullModeFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags);
+impl CullModeFlags {
+    pub const NONE: Self = CullModeFlags(0);
+    pub const FRONT: Self = CullModeFlags(0b1);
+    pub const BACK: Self = CullModeFlags(0b10);
+    pub const FRONT_AND_BACK: Self = CullModeFlags(0x0000_0003);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFlagBits.html>"]
+pub struct QueueFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(QueueFlags, 0b1111, Flags);
+impl QueueFlags {
+    #[doc = "Queue supports graphics operations"]
+    pub const GRAPHICS: Self = QueueFlags(0b1);
+    #[doc = "Queue supports compute operations"]
+    pub const COMPUTE: Self = QueueFlags(0b10);
+    #[doc = "Queue supports transfer operations"]
+    pub const TRANSFER: Self = QueueFlags(0b100);
+    #[doc = "Queue supports sparse resource memory management operations"]
+    pub const SPARSE_BINDING: Self = QueueFlags(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassCreateFlagBits.html>"]
+pub struct RenderPassCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(RenderPassCreateFlags, 0b0, Flags);
+impl RenderPassCreateFlags {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueCreateFlagBits.html>"]
+pub struct DeviceQueueCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(DeviceQueueCreateFlags, 0b0, Flags);
+impl DeviceQueueCreateFlags {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryPropertyFlagBits.html>"]
+pub struct MemoryPropertyFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(MemoryPropertyFlags, 0b1_1111, Flags);
+impl MemoryPropertyFlags {
+    #[doc = "If otherwise stated, then allocate memory on device"]
+    pub const DEVICE_LOCAL: Self = MemoryPropertyFlags(0b1);
+    #[doc = "Memory is mappable by host"]
+    pub const HOST_VISIBLE: Self = MemoryPropertyFlags(0b10);
+    #[doc = "Memory will have i/o coherency. If not set, application may need to use vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges to flush/invalidate host cache"]
+    pub const HOST_COHERENT: Self = MemoryPropertyFlags(0b100);
+    #[doc = "Memory will be cached by the host"]
+    pub const HOST_CACHED: Self = MemoryPropertyFlags(0b1000);
+    #[doc = "Memory may be allocated by the driver when it is required"]
+    pub const LAZILY_ALLOCATED: Self = MemoryPropertyFlags(0b1_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryHeapFlagBits.html>"]
+pub struct MemoryHeapFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(MemoryHeapFlags, 0b1, Flags);
+impl MemoryHeapFlags {
+    #[doc = "If set, heap represents device memory"]
+    pub const DEVICE_LOCAL: Self = MemoryHeapFlags(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccessFlagBits.html>"]
+pub struct AccessFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(AccessFlags, 0b1_1111_1111_1111_1111, Flags);
+impl AccessFlags {
+    #[doc = "Controls coherency of indirect command reads"]
+    pub const INDIRECT_COMMAND_READ: Self = AccessFlags(0b1);
+    #[doc = "Controls coherency of index reads"]
+    pub const INDEX_READ: Self = AccessFlags(0b10);
+    #[doc = "Controls coherency of vertex attribute reads"]
+    pub const VERTEX_ATTRIBUTE_READ: Self = AccessFlags(0b100);
+    #[doc = "Controls coherency of uniform buffer reads"]
+    pub const UNIFORM_READ: Self = AccessFlags(0b1000);
+    #[doc = "Controls coherency of input attachment reads"]
+    pub const INPUT_ATTACHMENT_READ: Self = AccessFlags(0b1_0000);
+    #[doc = "Controls coherency of shader reads"]
+    pub const SHADER_READ: Self = AccessFlags(0b10_0000);
+    #[doc = "Controls coherency of shader writes"]
+    pub const SHADER_WRITE: Self = AccessFlags(0b100_0000);
+    #[doc = "Controls coherency of color attachment reads"]
+    pub const COLOR_ATTACHMENT_READ: Self = AccessFlags(0b1000_0000);
+    #[doc = "Controls coherency of color attachment writes"]
+    pub const COLOR_ATTACHMENT_WRITE: Self = AccessFlags(0b1_0000_0000);
+    #[doc = "Controls coherency of depth/stencil attachment reads"]
+    pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = AccessFlags(0b10_0000_0000);
+    #[doc = "Controls coherency of depth/stencil attachment writes"]
+    pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = AccessFlags(0b100_0000_0000);
+    #[doc = "Controls coherency of transfer reads"]
+    pub const TRANSFER_READ: Self = AccessFlags(0b1000_0000_0000);
+    #[doc = "Controls coherency of transfer writes"]
+    pub const TRANSFER_WRITE: Self = AccessFlags(0b1_0000_0000_0000);
+    #[doc = "Controls coherency of host reads"]
+    pub const HOST_READ: Self = AccessFlags(0b10_0000_0000_0000);
+    #[doc = "Controls coherency of host writes"]
+    pub const HOST_WRITE: Self = AccessFlags(0b100_0000_0000_0000);
+    #[doc = "Controls coherency of memory reads"]
+    pub const MEMORY_READ: Self = AccessFlags(0b1000_0000_0000_0000);
+    #[doc = "Controls coherency of memory writes"]
+    pub const MEMORY_WRITE: Self = AccessFlags(0b1_0000_0000_0000_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferUsageFlagBits.html>"]
+pub struct BufferUsageFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(BufferUsageFlags, 0b1_1111_1111, Flags);
+impl BufferUsageFlags {
+    #[doc = "Can be used as a source of transfer operations"]
+    pub const TRANSFER_SRC: Self = BufferUsageFlags(0b1);
+    #[doc = "Can be used as a destination of transfer operations"]
+    pub const TRANSFER_DST: Self = BufferUsageFlags(0b10);
+    #[doc = "Can be used as TBO"]
+    pub const UNIFORM_TEXEL_BUFFER: Self = BufferUsageFlags(0b100);
+    #[doc = "Can be used as IBO"]
+    pub const STORAGE_TEXEL_BUFFER: Self = BufferUsageFlags(0b1000);
+    #[doc = "Can be used as UBO"]
+    pub const UNIFORM_BUFFER: Self = BufferUsageFlags(0b1_0000);
+    #[doc = "Can be used as SSBO"]
+    pub const STORAGE_BUFFER: Self = BufferUsageFlags(0b10_0000);
+    #[doc = "Can be used as source of fixed-function index fetch (index buffer)"]
+    pub const INDEX_BUFFER: Self = BufferUsageFlags(0b100_0000);
+    #[doc = "Can be used as source of fixed-function vertex fetch (VBO)"]
+    pub const VERTEX_BUFFER: Self = BufferUsageFlags(0b1000_0000);
+    #[doc = "Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)"]
+    pub const INDIRECT_BUFFER: Self = BufferUsageFlags(0b1_0000_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferCreateFlagBits.html>"]
+pub struct BufferCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(BufferCreateFlags, 0b111, Flags);
+impl BufferCreateFlags {
+    #[doc = "Buffer should support sparse backing"]
+    pub const SPARSE_BINDING: Self = BufferCreateFlags(0b1);
+    #[doc = "Buffer should support sparse backing with partial residency"]
+    pub const SPARSE_RESIDENCY: Self = BufferCreateFlags(0b10);
+    #[doc = "Buffer should support constent data access to physical memory ranges mapped into multiple locations of sparse buffers"]
+    pub const SPARSE_ALIASED: Self = BufferCreateFlags(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderStageFlagBits.html>"]
+pub struct ShaderStageFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(
+    ShaderStageFlags,
+    0b111_1111_1111_1111_1111_1111_1111_1111,
+    Flags
+);
+impl ShaderStageFlags {
+    pub const VERTEX: Self = ShaderStageFlags(0b1);
+    pub const TESSELLATION_CONTROL: Self = ShaderStageFlags(0b10);
+    pub const TESSELLATION_EVALUATION: Self = ShaderStageFlags(0b100);
+    pub const GEOMETRY: Self = ShaderStageFlags(0b1000);
+    pub const FRAGMENT: Self = ShaderStageFlags(0b1_0000);
+    pub const COMPUTE: Self = ShaderStageFlags(0b10_0000);
+    pub const ALL_GRAPHICS: Self = ShaderStageFlags(0x0000_001F);
+    pub const ALL: Self = ShaderStageFlags(0x7FFF_FFFF);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageUsageFlagBits.html>"]
+pub struct ImageUsageFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(ImageUsageFlags, 0b1111_1111, Flags);
+impl ImageUsageFlags {
+    #[doc = "Can be used as a source of transfer operations"]
+    pub const TRANSFER_SRC: Self = ImageUsageFlags(0b1);
+    #[doc = "Can be used as a destination of transfer operations"]
+    pub const TRANSFER_DST: Self = ImageUsageFlags(0b10);
+    #[doc = "Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"]
+    pub const SAMPLED: Self = ImageUsageFlags(0b100);
+    #[doc = "Can be used as storage image (STORAGE_IMAGE descriptor type)"]
+    pub const STORAGE: Self = ImageUsageFlags(0b1000);
+    #[doc = "Can be used as framebuffer color attachment"]
+    pub const COLOR_ATTACHMENT: Self = ImageUsageFlags(0b1_0000);
+    #[doc = "Can be used as framebuffer depth/stencil attachment"]
+    pub const DEPTH_STENCIL_ATTACHMENT: Self = ImageUsageFlags(0b10_0000);
+    #[doc = "Image data not needed outside of rendering"]
+    pub const TRANSIENT_ATTACHMENT: Self = ImageUsageFlags(0b100_0000);
+    #[doc = "Can be used as framebuffer input attachment"]
+    pub const INPUT_ATTACHMENT: Self = ImageUsageFlags(0b1000_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageCreateFlagBits.html>"]
+pub struct ImageCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(ImageCreateFlags, 0b1_1111, Flags);
+impl ImageCreateFlags {
+    #[doc = "Image should support sparse backing"]
+    pub const SPARSE_BINDING: Self = ImageCreateFlags(0b1);
+    #[doc = "Image should support sparse backing with partial residency"]
+    pub const SPARSE_RESIDENCY: Self = ImageCreateFlags(0b10);
+    #[doc = "Image should support constent data access to physical memory ranges mapped into multiple locations of sparse images"]
+    pub const SPARSE_ALIASED: Self = ImageCreateFlags(0b100);
+    #[doc = "Allows image views to have different format than the base image"]
+    pub const MUTABLE_FORMAT: Self = ImageCreateFlags(0b1000);
+    #[doc = "Allows creating image views with cube type from the created image"]
+    pub const CUBE_COMPATIBLE: Self = ImageCreateFlags(0b1_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewCreateFlagBits.html>"]
+pub struct ImageViewCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(ImageViewCreateFlags, 0b0, Flags);
+impl ImageViewCreateFlags {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerCreateFlagBits.html>"]
+pub struct SamplerCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(SamplerCreateFlags, 0b0, Flags);
+impl SamplerCreateFlags {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreateFlagBits.html>"]
+pub struct PipelineCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(PipelineCreateFlags, 0b111, Flags);
+impl PipelineCreateFlags {
+    pub const DISABLE_OPTIMIZATION: Self = PipelineCreateFlags(0b1);
+    pub const ALLOW_DERIVATIVES: Self = PipelineCreateFlags(0b10);
+    pub const DERIVATIVE: Self = PipelineCreateFlags(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineShaderStageCreateFlagBits.html>"]
+pub struct PipelineShaderStageCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, 0b0, Flags);
+impl PipelineShaderStageCreateFlags {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkColorComponentFlagBits.html>"]
+pub struct ColorComponentFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(ColorComponentFlags, 0b1111, Flags);
+impl ColorComponentFlags {
+    pub const R: Self = ColorComponentFlags(0b1);
+    pub const G: Self = ColorComponentFlags(0b10);
+    pub const B: Self = ColorComponentFlags(0b100);
+    pub const A: Self = ColorComponentFlags(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceCreateFlagBits.html>"]
+pub struct FenceCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(FenceCreateFlags, 0b1, Flags);
+impl FenceCreateFlags {
+    pub const SIGNALED: Self = FenceCreateFlags(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreCreateFlagBits.html>"]
+pub struct SemaphoreCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(SemaphoreCreateFlags, 0b0, Flags);
+impl SemaphoreCreateFlags {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatFeatureFlagBits.html>"]
+pub struct FormatFeatureFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(FormatFeatureFlags, 0b1_1111_1111_1111, Flags);
+impl FormatFeatureFlags {
+    #[doc = "Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"]
+    pub const SAMPLED_IMAGE: Self = FormatFeatureFlags(0b1);
+    #[doc = "Format can be used for storage images (STORAGE_IMAGE descriptor type)"]
+    pub const STORAGE_IMAGE: Self = FormatFeatureFlags(0b10);
+    #[doc = "Format supports atomic operations in case it is used for storage images"]
+    pub const STORAGE_IMAGE_ATOMIC: Self = FormatFeatureFlags(0b100);
+    #[doc = "Format can be used for uniform texel buffers (TBOs)"]
+    pub const UNIFORM_TEXEL_BUFFER: Self = FormatFeatureFlags(0b1000);
+    #[doc = "Format can be used for storage texel buffers (IBOs)"]
+    pub const STORAGE_TEXEL_BUFFER: Self = FormatFeatureFlags(0b1_0000);
+    #[doc = "Format supports atomic operations in case it is used for storage texel buffers"]
+    pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = FormatFeatureFlags(0b10_0000);
+    #[doc = "Format can be used for vertex buffers (VBOs)"]
+    pub const VERTEX_BUFFER: Self = FormatFeatureFlags(0b100_0000);
+    #[doc = "Format can be used for color attachment images"]
+    pub const COLOR_ATTACHMENT: Self = FormatFeatureFlags(0b1000_0000);
+    #[doc = "Format supports blending in case it is used for color attachment images"]
+    pub const COLOR_ATTACHMENT_BLEND: Self = FormatFeatureFlags(0b1_0000_0000);
+    #[doc = "Format can be used for depth/stencil attachment images"]
+    pub const DEPTH_STENCIL_ATTACHMENT: Self = FormatFeatureFlags(0b10_0000_0000);
+    #[doc = "Format can be used as the source image of blits with vkCmdBlitImage"]
+    pub const BLIT_SRC: Self = FormatFeatureFlags(0b100_0000_0000);
+    #[doc = "Format can be used as the destination image of blits with vkCmdBlitImage"]
+    pub const BLIT_DST: Self = FormatFeatureFlags(0b1000_0000_0000);
+    #[doc = "Format can be filtered with VK_FILTER_LINEAR when being sampled"]
+    pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = FormatFeatureFlags(0b1_0000_0000_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryControlFlagBits.html>"]
+pub struct QueryControlFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags);
+impl QueryControlFlags {
+    #[doc = "Require precise results to be collected by the query"]
+    pub const PRECISE: Self = QueryControlFlags(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryResultFlagBits.html>"]
+pub struct QueryResultFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags);
+impl QueryResultFlags {
+    #[doc = "Results of the queries are written to the destination buffer as 64-bit values"]
+    pub const TYPE_64: Self = QueryResultFlags(0b1);
+    #[doc = "Results of the queries are waited on before proceeding with the result copy"]
+    pub const WAIT: Self = QueryResultFlags(0b10);
+    #[doc = "Besides the results of the query, the availability of the results is also written"]
+    pub const WITH_AVAILABILITY: Self = QueryResultFlags(0b100);
+    #[doc = "Copy the partial results of the query even if the final results are not available"]
+    pub const PARTIAL: Self = QueryResultFlags(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferUsageFlagBits.html>"]
+pub struct CommandBufferUsageFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags);
+impl CommandBufferUsageFlags {
+    pub const ONE_TIME_SUBMIT: Self = CommandBufferUsageFlags(0b1);
+    pub const RENDER_PASS_CONTINUE: Self = CommandBufferUsageFlags(0b10);
+    #[doc = "Command buffer may be submitted/executed more than once simultaneously"]
+    pub const SIMULTANEOUS_USE: Self = CommandBufferUsageFlags(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPipelineStatisticFlagBits.html>"]
+pub struct QueryPipelineStatisticFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b111_1111_1111, Flags);
+impl QueryPipelineStatisticFlags {
+    #[doc = "Optional"]
+    pub const INPUT_ASSEMBLY_VERTICES: Self = QueryPipelineStatisticFlags(0b1);
+    #[doc = "Optional"]
+    pub const INPUT_ASSEMBLY_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b10);
+    #[doc = "Optional"]
+    pub const VERTEX_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b100);
+    #[doc = "Optional"]
+    pub const GEOMETRY_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b1000);
+    #[doc = "Optional"]
+    pub const GEOMETRY_SHADER_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b1_0000);
+    #[doc = "Optional"]
+    pub const CLIPPING_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b10_0000);
+    #[doc = "Optional"]
+    pub const CLIPPING_PRIMITIVES: Self = QueryPipelineStatisticFlags(0b100_0000);
+    #[doc = "Optional"]
+    pub const FRAGMENT_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b1000_0000);
+    #[doc = "Optional"]
+    pub const TESSELLATION_CONTROL_SHADER_PATCHES: Self =
+        QueryPipelineStatisticFlags(0b1_0000_0000);
+    #[doc = "Optional"]
+    pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS: Self =
+        QueryPipelineStatisticFlags(0b10_0000_0000);
+    #[doc = "Optional"]
+    pub const COMPUTE_SHADER_INVOCATIONS: Self = QueryPipelineStatisticFlags(0b100_0000_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageAspectFlagBits.html>"]
+pub struct ImageAspectFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags);
+impl ImageAspectFlags {
+    pub const COLOR: Self = ImageAspectFlags(0b1);
+    pub const DEPTH: Self = ImageAspectFlags(0b10);
+    pub const STENCIL: Self = ImageAspectFlags(0b100);
+    pub const METADATA: Self = ImageAspectFlags(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageFormatFlagBits.html>"]
+pub struct SparseImageFormatFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags);
+impl SparseImageFormatFlags {
+    #[doc = "Image uses a single mip tail region for all array layers"]
+    pub const SINGLE_MIPTAIL: Self = SparseImageFormatFlags(0b1);
+    #[doc = "Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels."]
+    pub const ALIGNED_MIP_SIZE: Self = SparseImageFormatFlags(0b10);
+    #[doc = "Image uses a non-standard sparse image block dimensions"]
+    pub const NONSTANDARD_BLOCK_SIZE: Self = SparseImageFormatFlags(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseMemoryBindFlagBits.html>"]
+pub struct SparseMemoryBindFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags);
+impl SparseMemoryBindFlags {
+    #[doc = "Operation binds resource metadata to memory"]
+    pub const METADATA: Self = SparseMemoryBindFlags(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineStageFlagBits.html>"]
+pub struct PipelineStageFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(PipelineStageFlags, 0b1_1111_1111_1111_1111, Flags);
+impl PipelineStageFlags {
+    #[doc = "Before subsequent commands are processed"]
+    pub const TOP_OF_PIPE: Self = PipelineStageFlags(0b1);
+    #[doc = "Draw/DispatchIndirect command fetch"]
+    pub const DRAW_INDIRECT: Self = PipelineStageFlags(0b10);
+    #[doc = "Vertex/index fetch"]
+    pub const VERTEX_INPUT: Self = PipelineStageFlags(0b100);
+    #[doc = "Vertex shading"]
+    pub const VERTEX_SHADER: Self = PipelineStageFlags(0b1000);
+    #[doc = "Tessellation control shading"]
+    pub const TESSELLATION_CONTROL_SHADER: Self = PipelineStageFlags(0b1_0000);
+    #[doc = "Tessellation evaluation shading"]
+    pub const TESSELLATION_EVALUATION_SHADER: Self = PipelineStageFlags(0b10_0000);
+    #[doc = "Geometry shading"]
+    pub const GEOMETRY_SHADER: Self = PipelineStageFlags(0b100_0000);
+    #[doc = "Fragment shading"]
+    pub const FRAGMENT_SHADER: Self = PipelineStageFlags(0b1000_0000);
+    #[doc = "Early fragment (depth and stencil) tests"]
+    pub const EARLY_FRAGMENT_TESTS: Self = PipelineStageFlags(0b1_0000_0000);
+    #[doc = "Late fragment (depth and stencil) tests"]
+    pub const LATE_FRAGMENT_TESTS: Self = PipelineStageFlags(0b10_0000_0000);
+    #[doc = "Color attachment writes"]
+    pub const COLOR_ATTACHMENT_OUTPUT: Self = PipelineStageFlags(0b100_0000_0000);
+    #[doc = "Compute shading"]
+    pub const COMPUTE_SHADER: Self = PipelineStageFlags(0b1000_0000_0000);
+    #[doc = "Transfer/copy operations"]
+    pub const TRANSFER: Self = PipelineStageFlags(0b1_0000_0000_0000);
+    #[doc = "After previous commands have completed"]
+    pub const BOTTOM_OF_PIPE: Self = PipelineStageFlags(0b10_0000_0000_0000);
+    #[doc = "Indicates host (CPU) is a source/sink of the dependency"]
+    pub const HOST: Self = PipelineStageFlags(0b100_0000_0000_0000);
+    #[doc = "All stages of the graphics pipeline"]
+    pub const ALL_GRAPHICS: Self = PipelineStageFlags(0b1000_0000_0000_0000);
+    #[doc = "All stages supported on the queue"]
+    pub const ALL_COMMANDS: Self = PipelineStageFlags(0b1_0000_0000_0000_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolCreateFlagBits.html>"]
+pub struct CommandPoolCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags);
+impl CommandPoolCreateFlags {
+    #[doc = "Command buffers have a short lifetime"]
+    pub const TRANSIENT: Self = CommandPoolCreateFlags(0b1);
+    #[doc = "Command buffers may release their memory individually"]
+    pub const RESET_COMMAND_BUFFER: Self = CommandPoolCreateFlags(0b10);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolResetFlagBits.html>"]
+pub struct CommandPoolResetFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags);
+impl CommandPoolResetFlags {
+    #[doc = "Release resources owned by the pool"]
+    pub const RELEASE_RESOURCES: Self = CommandPoolResetFlags(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferResetFlagBits.html>"]
+pub struct CommandBufferResetFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags);
+impl CommandBufferResetFlags {
+    #[doc = "Release resources owned by the buffer"]
+    pub const RELEASE_RESOURCES: Self = CommandBufferResetFlags(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleCountFlagBits.html>"]
+pub struct SampleCountFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(SampleCountFlags, 0b111_1111, Flags);
+impl SampleCountFlags {
+    #[doc = "Sample count 1 supported"]
+    pub const TYPE_1: Self = SampleCountFlags(0b1);
+    #[doc = "Sample count 2 supported"]
+    pub const TYPE_2: Self = SampleCountFlags(0b10);
+    #[doc = "Sample count 4 supported"]
+    pub const TYPE_4: Self = SampleCountFlags(0b100);
+    #[doc = "Sample count 8 supported"]
+    pub const TYPE_8: Self = SampleCountFlags(0b1000);
+    #[doc = "Sample count 16 supported"]
+    pub const TYPE_16: Self = SampleCountFlags(0b1_0000);
+    #[doc = "Sample count 32 supported"]
+    pub const TYPE_32: Self = SampleCountFlags(0b10_0000);
+    #[doc = "Sample count 64 supported"]
+    pub const TYPE_64: Self = SampleCountFlags(0b100_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescriptionFlagBits.html>"]
+pub struct AttachmentDescriptionFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags);
+impl AttachmentDescriptionFlags {
+    #[doc = "The attachment may alias physical memory of another attachment in the same render pass"]
+    pub const MAY_ALIAS: Self = AttachmentDescriptionFlags(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStencilFaceFlagBits.html>"]
+pub struct StencilFaceFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags);
+impl StencilFaceFlags {
+    #[doc = "Front face"]
+    pub const FRONT: Self = StencilFaceFlags(0b1);
+    #[doc = "Back face"]
+    pub const BACK: Self = StencilFaceFlags(0b10);
+    #[doc = "Front and back faces"]
+    pub const FRONT_AND_BACK: Self = StencilFaceFlags(0x0000_0003);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolCreateFlagBits.html>"]
+pub struct DescriptorPoolCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags);
+impl DescriptorPoolCreateFlags {
+    #[doc = "Descriptor sets may be freed individually"]
+    pub const FREE_DESCRIPTOR_SET: Self = DescriptorPoolCreateFlags(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDependencyFlagBits.html>"]
+pub struct DependencyFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags);
+impl DependencyFlags {
+    #[doc = "Dependency is per pixel region "]
+    pub const BY_REGION: Self = DependencyFlags(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreWaitFlagBits.html>"]
+pub struct SemaphoreWaitFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(SemaphoreWaitFlags, 0b1, Flags);
+impl SemaphoreWaitFlags {
+    pub const ANY: Self = SemaphoreWaitFlags(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneAlphaFlagBitsKHR.html>"]
+pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags);
+impl DisplayPlaneAlphaFlagsKHR {
+    pub const OPAQUE: Self = DisplayPlaneAlphaFlagsKHR(0b1);
+    pub const GLOBAL: Self = DisplayPlaneAlphaFlagsKHR(0b10);
+    pub const PER_PIXEL: Self = DisplayPlaneAlphaFlagsKHR(0b100);
+    pub const PER_PIXEL_PREMULTIPLIED: Self = DisplayPlaneAlphaFlagsKHR(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCompositeAlphaFlagBitsKHR.html>"]
+pub struct CompositeAlphaFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags);
+impl CompositeAlphaFlagsKHR {
+    pub const OPAQUE: Self = CompositeAlphaFlagsKHR(0b1);
+    pub const PRE_MULTIPLIED: Self = CompositeAlphaFlagsKHR(0b10);
+    pub const POST_MULTIPLIED: Self = CompositeAlphaFlagsKHR(0b100);
+    pub const INHERIT: Self = CompositeAlphaFlagsKHR(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceTransformFlagBitsKHR.html>"]
+pub struct SurfaceTransformFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b1_1111_1111, Flags);
+impl SurfaceTransformFlagsKHR {
+    pub const IDENTITY: Self = SurfaceTransformFlagsKHR(0b1);
+    pub const ROTATE_90: Self = SurfaceTransformFlagsKHR(0b10);
+    pub const ROTATE_180: Self = SurfaceTransformFlagsKHR(0b100);
+    pub const ROTATE_270: Self = SurfaceTransformFlagsKHR(0b1000);
+    pub const HORIZONTAL_MIRROR: Self = SurfaceTransformFlagsKHR(0b1_0000);
+    pub const HORIZONTAL_MIRROR_ROTATE_90: Self = SurfaceTransformFlagsKHR(0b10_0000);
+    pub const HORIZONTAL_MIRROR_ROTATE_180: Self = SurfaceTransformFlagsKHR(0b100_0000);
+    pub const HORIZONTAL_MIRROR_ROTATE_270: Self = SurfaceTransformFlagsKHR(0b1000_0000);
+    pub const INHERIT: Self = SurfaceTransformFlagsKHR(0b1_0000_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainImageUsageFlagBitsANDROID.html>"]
+pub struct SwapchainImageUsageFlagsANDROID(pub(crate) Flags);
+vk_bitflags_wrapped!(SwapchainImageUsageFlagsANDROID, 0b1, Flags);
+impl SwapchainImageUsageFlagsANDROID {
+    pub const SHARED: Self = SwapchainImageUsageFlagsANDROID(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugReportFlagBitsEXT.html>"]
+pub struct DebugReportFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b1_1111, Flags);
+impl DebugReportFlagsEXT {
+    pub const INFORMATION: Self = DebugReportFlagsEXT(0b1);
+    pub const WARNING: Self = DebugReportFlagsEXT(0b10);
+    pub const PERFORMANCE_WARNING: Self = DebugReportFlagsEXT(0b100);
+    pub const ERROR: Self = DebugReportFlagsEXT(0b1000);
+    pub const DEBUG: Self = DebugReportFlagsEXT(0b1_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryHandleTypeFlagBitsNV.html>"]
+pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags);
+vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags);
+impl ExternalMemoryHandleTypeFlagsNV {
+    pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV: Self =
+        ExternalMemoryHandleTypeFlagsNV(0b1);
+    pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV: Self =
+        ExternalMemoryHandleTypeFlagsNV(0b10);
+    pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV: Self =
+        ExternalMemoryHandleTypeFlagsNV(0b100);
+    pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV: Self =
+        ExternalMemoryHandleTypeFlagsNV(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryFeatureFlagBitsNV.html>"]
+pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags);
+vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags);
+impl ExternalMemoryFeatureFlagsNV {
+    pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV: Self = ExternalMemoryFeatureFlagsNV(0b1);
+    pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b10);
+    pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV: Self = ExternalMemoryFeatureFlagsNV(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubgroupFeatureFlagBits.html>"]
+pub struct SubgroupFeatureFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(SubgroupFeatureFlags, 0b1111_1111, Flags);
+impl SubgroupFeatureFlags {
+    #[doc = "Basic subgroup operations"]
+    pub const BASIC: Self = SubgroupFeatureFlags(0b1);
+    #[doc = "Vote subgroup operations"]
+    pub const VOTE: Self = SubgroupFeatureFlags(0b10);
+    #[doc = "Arithmetic subgroup operations"]
+    pub const ARITHMETIC: Self = SubgroupFeatureFlags(0b100);
+    #[doc = "Ballot subgroup operations"]
+    pub const BALLOT: Self = SubgroupFeatureFlags(0b1000);
+    #[doc = "Shuffle subgroup operations"]
+    pub const SHUFFLE: Self = SubgroupFeatureFlags(0b1_0000);
+    #[doc = "Shuffle relative subgroup operations"]
+    pub const SHUFFLE_RELATIVE: Self = SubgroupFeatureFlags(0b10_0000);
+    #[doc = "Clustered subgroup operations"]
+    pub const CLUSTERED: Self = SubgroupFeatureFlags(0b100_0000);
+    #[doc = "Quad subgroup operations"]
+    pub const QUAD: Self = SubgroupFeatureFlags(0b1000_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutUsageFlagBitsNV.html>"]
+pub struct IndirectCommandsLayoutUsageFlagsNV(pub(crate) Flags);
+vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNV, 0b111, Flags);
+impl IndirectCommandsLayoutUsageFlagsNV {
+    pub const EXPLICIT_PREPROCESS: Self = IndirectCommandsLayoutUsageFlagsNV(0b1);
+    pub const INDEXED_SEQUENCES: Self = IndirectCommandsLayoutUsageFlagsNV(0b10);
+    pub const UNORDERED_SEQUENCES: Self = IndirectCommandsLayoutUsageFlagsNV(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectStateFlagBitsNV.html>"]
+pub struct IndirectStateFlagsNV(pub(crate) Flags);
+vk_bitflags_wrapped!(IndirectStateFlagsNV, 0b1, Flags);
+impl IndirectStateFlagsNV {
+    pub const FLAG_FRONTFACE: Self = IndirectStateFlagsNV(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutCreateFlagBits.html>"]
+pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags);
+impl DescriptorSetLayoutCreateFlags {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryHandleTypeFlagBits.html>"]
+pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b111_1111, Flags);
+impl ExternalMemoryHandleTypeFlags {
+    pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD: Self = ExternalMemoryHandleTypeFlags(0b1);
+    pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32: Self = ExternalMemoryHandleTypeFlags(0b10);
+    pub const EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self =
+        ExternalMemoryHandleTypeFlags(0b100);
+    pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE: Self =
+        ExternalMemoryHandleTypeFlags(0b1000);
+    pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT: Self =
+        ExternalMemoryHandleTypeFlags(0b1_0000);
+    pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP: Self =
+        ExternalMemoryHandleTypeFlags(0b10_0000);
+    pub const EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE: Self =
+        ExternalMemoryHandleTypeFlags(0b100_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryFeatureFlagBits.html>"]
+pub struct ExternalMemoryFeatureFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags);
+impl ExternalMemoryFeatureFlags {
+    pub const EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY: Self = ExternalMemoryFeatureFlags(0b1);
+    pub const EXTERNAL_MEMORY_FEATURE_EXPORTABLE: Self = ExternalMemoryFeatureFlags(0b10);
+    pub const EXTERNAL_MEMORY_FEATURE_IMPORTABLE: Self = ExternalMemoryFeatureFlags(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreHandleTypeFlagBits.html>"]
+pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b1_1111, Flags);
+impl ExternalSemaphoreHandleTypeFlags {
+    pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD: Self =
+        ExternalSemaphoreHandleTypeFlags(0b1);
+    pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32: Self =
+        ExternalSemaphoreHandleTypeFlags(0b10);
+    pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self =
+        ExternalSemaphoreHandleTypeFlags(0b100);
+    pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE: Self =
+        ExternalSemaphoreHandleTypeFlags(0b1000);
+    pub const EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD: Self =
+        ExternalSemaphoreHandleTypeFlags(0b1_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreFeatureFlagBits.html>"]
+pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags);
+impl ExternalSemaphoreFeatureFlags {
+    pub const EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b1);
+    pub const EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE: Self = ExternalSemaphoreFeatureFlags(0b10);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreImportFlagBits.html>"]
+pub struct SemaphoreImportFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(SemaphoreImportFlags, 0b1, Flags);
+impl SemaphoreImportFlags {
+    pub const TEMPORARY: Self = SemaphoreImportFlags(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceHandleTypeFlagBits.html>"]
+pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags);
+impl ExternalFenceHandleTypeFlags {
+    pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD: Self = ExternalFenceHandleTypeFlags(0b1);
+    pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32: Self = ExternalFenceHandleTypeFlags(0b10);
+    pub const EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT: Self =
+        ExternalFenceHandleTypeFlags(0b100);
+    pub const EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD: Self = ExternalFenceHandleTypeFlags(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceFeatureFlagBits.html>"]
+pub struct ExternalFenceFeatureFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags);
+impl ExternalFenceFeatureFlags {
+    pub const EXTERNAL_FENCE_FEATURE_EXPORTABLE: Self = ExternalFenceFeatureFlags(0b1);
+    pub const EXTERNAL_FENCE_FEATURE_IMPORTABLE: Self = ExternalFenceFeatureFlags(0b10);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceImportFlagBits.html>"]
+pub struct FenceImportFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(FenceImportFlags, 0b1, Flags);
+impl FenceImportFlags {
+    pub const TEMPORARY: Self = FenceImportFlags(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCounterFlagBitsEXT.html>"]
+pub struct SurfaceCounterFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags);
+impl SurfaceCounterFlagsEXT {
+    pub const VBLANK: Self = SurfaceCounterFlagsEXT(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPeerMemoryFeatureFlagBits.html>"]
+pub struct PeerMemoryFeatureFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(PeerMemoryFeatureFlags, 0b1111, Flags);
+impl PeerMemoryFeatureFlags {
+    #[doc = "Can read with vkCmdCopy commands"]
+    pub const COPY_SRC: Self = PeerMemoryFeatureFlags(0b1);
+    #[doc = "Can write with vkCmdCopy commands"]
+    pub const COPY_DST: Self = PeerMemoryFeatureFlags(0b10);
+    #[doc = "Can read with any access type/command"]
+    pub const GENERIC_SRC: Self = PeerMemoryFeatureFlags(0b100);
+    #[doc = "Can write with and access type/command"]
+    pub const GENERIC_DST: Self = PeerMemoryFeatureFlags(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryAllocateFlagBits.html>"]
+pub struct MemoryAllocateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(MemoryAllocateFlags, 0b1, Flags);
+impl MemoryAllocateFlags {
+    #[doc = "Force allocation on specific devices"]
+    pub const DEVICE_MASK: Self = MemoryAllocateFlags(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupPresentModeFlagBitsKHR.html>"]
+pub struct DeviceGroupPresentModeFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags);
+impl DeviceGroupPresentModeFlagsKHR {
+    #[doc = "Present from local memory"]
+    pub const LOCAL: Self = DeviceGroupPresentModeFlagsKHR(0b1);
+    #[doc = "Present from remote memory"]
+    pub const REMOTE: Self = DeviceGroupPresentModeFlagsKHR(0b10);
+    #[doc = "Present sum of local and/or remote memory"]
+    pub const SUM: Self = DeviceGroupPresentModeFlagsKHR(0b100);
+    #[doc = "Each physical device presents from local memory"]
+    pub const LOCAL_MULTI_DEVICE: Self = DeviceGroupPresentModeFlagsKHR(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainCreateFlagBitsKHR.html>"]
+pub struct SwapchainCreateFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags);
+impl SwapchainCreateFlagsKHR {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescriptionFlagBits.html>"]
+pub struct SubpassDescriptionFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags);
+impl SubpassDescriptionFlags {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessageSeverityFlagBitsEXT.html>"]
+pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, 0b1_0001_0001_0001, Flags);
+impl DebugUtilsMessageSeverityFlagsEXT {
+    pub const VERBOSE: Self = DebugUtilsMessageSeverityFlagsEXT(0b1);
+    pub const INFO: Self = DebugUtilsMessageSeverityFlagsEXT(0b1_0000);
+    pub const WARNING: Self = DebugUtilsMessageSeverityFlagsEXT(0b1_0000_0000);
+    pub const ERROR: Self = DebugUtilsMessageSeverityFlagsEXT(0b1_0000_0000_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessageTypeFlagBitsEXT.html>"]
+pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, 0b111, Flags);
+impl DebugUtilsMessageTypeFlagsEXT {
+    pub const GENERAL: Self = DebugUtilsMessageTypeFlagsEXT(0b1);
+    pub const VALIDATION: Self = DebugUtilsMessageTypeFlagsEXT(0b10);
+    pub const PERFORMANCE: Self = DebugUtilsMessageTypeFlagsEXT(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorBindingFlagBits.html>"]
+pub struct DescriptorBindingFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(DescriptorBindingFlags, 0b1111, Flags);
+impl DescriptorBindingFlags {
+    pub const UPDATE_AFTER_BIND: Self = DescriptorBindingFlags(0b1);
+    pub const UPDATE_UNUSED_WHILE_PENDING: Self = DescriptorBindingFlags(0b10);
+    pub const PARTIALLY_BOUND: Self = DescriptorBindingFlags(0b100);
+    pub const VARIABLE_DESCRIPTOR_COUNT: Self = DescriptorBindingFlags(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkConditionalRenderingFlagBitsEXT.html>"]
+pub struct ConditionalRenderingFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(ConditionalRenderingFlagsEXT, 0b1, Flags);
+impl ConditionalRenderingFlagsEXT {
+    pub const INVERTED: Self = ConditionalRenderingFlagsEXT(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkResolveModeFlagBits.html>"]
+pub struct ResolveModeFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(ResolveModeFlags, 0b1111, Flags);
+impl ResolveModeFlags {
+    pub const NONE: Self = ResolveModeFlags(0);
+    pub const SAMPLE_ZERO: Self = ResolveModeFlags(0b1);
+    pub const AVERAGE: Self = ResolveModeFlags(0b10);
+    pub const MIN: Self = ResolveModeFlags(0b100);
+    pub const MAX: Self = ResolveModeFlags(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryInstanceFlagBitsKHR.html>"]
+pub struct GeometryInstanceFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(GeometryInstanceFlagsKHR, 0b1111, Flags);
+impl GeometryInstanceFlagsKHR {
+    pub const TRIANGLE_FACING_CULL_DISABLE: Self = GeometryInstanceFlagsKHR(0b1);
+    pub const TRIANGLE_FRONT_COUNTERCLOCKWISE: Self = GeometryInstanceFlagsKHR(0b10);
+    pub const FORCE_OPAQUE: Self = GeometryInstanceFlagsKHR(0b100);
+    pub const FORCE_NO_OPAQUE: Self = GeometryInstanceFlagsKHR(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryFlagBitsKHR.html>"]
+pub struct GeometryFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(GeometryFlagsKHR, 0b11, Flags);
+impl GeometryFlagsKHR {
+    pub const OPAQUE: Self = GeometryFlagsKHR(0b1);
+    pub const NO_DUPLICATE_ANY_HIT_INVOCATION: Self = GeometryFlagsKHR(0b10);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBuildAccelerationStructureFlagBitsKHR.html>"]
+pub struct BuildAccelerationStructureFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(BuildAccelerationStructureFlagsKHR, 0b1_1111, Flags);
+impl BuildAccelerationStructureFlagsKHR {
+    pub const ALLOW_UPDATE: Self = BuildAccelerationStructureFlagsKHR(0b1);
+    pub const ALLOW_COMPACTION: Self = BuildAccelerationStructureFlagsKHR(0b10);
+    pub const PREFER_FAST_TRACE: Self = BuildAccelerationStructureFlagsKHR(0b100);
+    pub const PREFER_FAST_BUILD: Self = BuildAccelerationStructureFlagsKHR(0b1000);
+    pub const LOW_MEMORY: Self = BuildAccelerationStructureFlagsKHR(0b1_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferCreateFlagBits.html>"]
+pub struct FramebufferCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(FramebufferCreateFlags, 0b0, Flags);
+impl FramebufferCreateFlags {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceDiagnosticsConfigFlagBitsNV.html>"]
+pub struct DeviceDiagnosticsConfigFlagsNV(pub(crate) Flags);
+vk_bitflags_wrapped!(DeviceDiagnosticsConfigFlagsNV, 0b111, Flags);
+impl DeviceDiagnosticsConfigFlagsNV {
+    pub const ENABLE_SHADER_DEBUG_INFO: Self = DeviceDiagnosticsConfigFlagsNV(0b1);
+    pub const ENABLE_RESOURCE_TRACKING: Self = DeviceDiagnosticsConfigFlagsNV(0b10);
+    pub const ENABLE_AUTOMATIC_CHECKPOINTS: Self = DeviceDiagnosticsConfigFlagsNV(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreationFeedbackFlagBitsEXT.html>"]
+pub struct PipelineCreationFeedbackFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(PipelineCreationFeedbackFlagsEXT, 0b111, Flags);
+impl PipelineCreationFeedbackFlagsEXT {
+    pub const VALID: Self = PipelineCreationFeedbackFlagsEXT(0b1);
+    pub const APPLICATION_PIPELINE_CACHE_HIT: Self = PipelineCreationFeedbackFlagsEXT(0b10);
+    pub const BASE_PIPELINE_ACCELERATION: Self = PipelineCreationFeedbackFlagsEXT(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterDescriptionFlagBitsKHR.html>"]
+pub struct PerformanceCounterDescriptionFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(PerformanceCounterDescriptionFlagsKHR, 0b11, Flags);
+impl PerformanceCounterDescriptionFlagsKHR {
+    pub const PERFORMANCE_IMPACTING: Self = PerformanceCounterDescriptionFlagsKHR(0b1);
+    pub const CONCURRENTLY_IMPACTED: Self = PerformanceCounterDescriptionFlagsKHR(0b10);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAcquireProfilingLockFlagBitsKHR.html>"]
+pub struct AcquireProfilingLockFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(AcquireProfilingLockFlagsKHR, 0b0, Flags);
+impl AcquireProfilingLockFlagsKHR {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderCorePropertiesFlagBitsAMD.html>"]
+pub struct ShaderCorePropertiesFlagsAMD(pub(crate) Flags);
+vk_bitflags_wrapped!(ShaderCorePropertiesFlagsAMD, 0b0, Flags);
+impl ShaderCorePropertiesFlagsAMD {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModuleCreateFlagBits.html>"]
+pub struct ShaderModuleCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(ShaderModuleCreateFlags, 0b0, Flags);
+impl ShaderModuleCreateFlags {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCompilerControlFlagBitsAMD.html>"]
+pub struct PipelineCompilerControlFlagsAMD(pub(crate) Flags);
+vk_bitflags_wrapped!(PipelineCompilerControlFlagsAMD, 0b0, Flags);
+impl PipelineCompilerControlFlagsAMD {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkToolPurposeFlagBitsEXT.html>"]
+pub struct ToolPurposeFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(ToolPurposeFlagsEXT, 0b1_1111, Flags);
+impl ToolPurposeFlagsEXT {
+    pub const VALIDATION: Self = ToolPurposeFlagsEXT(0b1);
+    pub const PROFILING: Self = ToolPurposeFlagsEXT(0b10);
+    pub const TRACING: Self = ToolPurposeFlagsEXT(0b100);
+    pub const ADDITIONAL_FEATURES: Self = ToolPurposeFlagsEXT(0b1000);
+    pub const MODIFYING_FEATURES: Self = ToolPurposeFlagsEXT(0b1_0000);
+}

ash/src/vk/constants.rs

@@ -0,0 +1,24 @@
+use crate::vk::definitions::*;
+pub const MAX_PHYSICAL_DEVICE_NAME_SIZE: usize = (256);
+pub const UUID_SIZE: usize = (16);
+pub const LUID_SIZE: usize = (8);
+pub const MAX_EXTENSION_NAME_SIZE: usize = (256);
+pub const MAX_DESCRIPTION_SIZE: usize = (256);
+pub const MAX_MEMORY_TYPES: usize = (32);
+pub const MAX_MEMORY_HEAPS: usize = (16);
+pub const LOD_CLAMP_NONE: f32 = (1000.00);
+pub const REMAINING_MIP_LEVELS: u32 = (!0);
+pub const REMAINING_ARRAY_LAYERS: u32 = (!0);
+pub const WHOLE_SIZE: u64 = (!0);
+pub const ATTACHMENT_UNUSED: u32 = (!0);
+pub const TRUE: Bool32 = (1);
+pub const FALSE: Bool32 = (0);
+pub const QUEUE_FAMILY_IGNORED: u32 = (!0);
+pub const QUEUE_FAMILY_EXTERNAL: u32 = (!0 - 1);
+pub const QUEUE_FAMILY_FOREIGN_EXT: u32 = (!0 - 2);
+pub const SUBPASS_EXTERNAL: u32 = (!0);
+pub const MAX_DEVICE_GROUP_SIZE: usize = (32);
+pub const MAX_DRIVER_NAME_SIZE: usize = (256);
+pub const MAX_DRIVER_INFO_SIZE: usize = (256);
+pub const SHADER_UNUSED_KHR: u32 = (!0);
+pub const SHADER_UNUSED_NV: u32 = SHADER_UNUSED_KHR;

ash/src/vk/feature_extensions.rs

@@ -0,0 +1,815 @@
+use crate::vk::bitflags::*;
+use crate::vk::enums::*;
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: Self = StructureType(1_000_094_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const BIND_BUFFER_MEMORY_INFO: Self = StructureType(1_000_157_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const BIND_IMAGE_MEMORY_INFO: Self = StructureType(1_000_157_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl ImageCreateFlags {
+    pub const ALIAS: Self = ImageCreateFlags(0b100_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: Self = StructureType(1_000_083_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const MEMORY_DEDICATED_REQUIREMENTS: Self = StructureType(1_000_127_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const MEMORY_DEDICATED_ALLOCATE_INFO: Self = StructureType(1_000_127_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const MEMORY_ALLOCATE_FLAGS_INFO: Self = StructureType(1_000_060_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: Self = StructureType(1_000_060_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: Self = StructureType(1_000_060_004);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const DEVICE_GROUP_SUBMIT_INFO: Self = StructureType(1_000_060_005);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const DEVICE_GROUP_BIND_SPARSE_INFO: Self = StructureType(1_000_060_006);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl PipelineCreateFlags {
+    pub const VIEW_INDEX_FROM_DEVICE_INDEX: Self = PipelineCreateFlags(0b1000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl PipelineCreateFlags {
+    pub const DISPATCH_BASE: Self = PipelineCreateFlags(0b1_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl DependencyFlags {
+    pub const DEVICE_GROUP: Self = DependencyFlags(0b100);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: Self = StructureType(1_000_060_013);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: Self = StructureType(1_000_060_014);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl ImageCreateFlags {
+    pub const SPLIT_INSTANCE_BIND_REGIONS: Self = ImageCreateFlags(0b100_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_GROUP_PROPERTIES: Self = StructureType(1_000_070_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const DEVICE_GROUP_DEVICE_CREATE_INFO: Self = StructureType(1_000_070_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl MemoryHeapFlags {
+    pub const MULTI_INSTANCE: Self = MemoryHeapFlags(0b10);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1_000_146_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1_000_146_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: Self = StructureType(1_000_146_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const MEMORY_REQUIREMENTS_2: Self = StructureType(1_000_146_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: Self = StructureType(1_000_146_004);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_FEATURES_2: Self = StructureType(1_000_059_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_PROPERTIES_2: Self = StructureType(1_000_059_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const FORMAT_PROPERTIES_2: Self = StructureType(1_000_059_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const IMAGE_FORMAT_PROPERTIES_2: Self = StructureType(1_000_059_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: Self = StructureType(1_000_059_004);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const QUEUE_FAMILY_PROPERTIES_2: Self = StructureType(1_000_059_005);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: Self = StructureType(1_000_059_006);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2: Self = StructureType(1_000_059_007);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: Self = StructureType(1_000_059_008);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Result {
+    pub const ERROR_OUT_OF_POOL_MEMORY: Self = Result(-1_000_069_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl FormatFeatureFlags {
+    pub const TRANSFER_SRC: Self = FormatFeatureFlags(0b100_0000_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl FormatFeatureFlags {
+    pub const TRANSFER_DST: Self = FormatFeatureFlags(0b1000_0000_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl ImageCreateFlags {
+    pub const TYPE_2D_ARRAY_COMPATIBLE: Self = ImageCreateFlags(0b10_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl ImageCreateFlags {
+    pub const BLOCK_TEXEL_VIEW_COMPATIBLE: Self = ImageCreateFlags(0b1000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl ImageCreateFlags {
+    pub const EXTENDED_USAGE: Self = ImageCreateFlags(0b1_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: Self = StructureType(1_000_117_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: Self = StructureType(1_000_117_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const IMAGE_VIEW_USAGE_CREATE_INFO: Self = StructureType(1_000_117_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: Self =
+        StructureType(1_000_117_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl ImageLayout {
+    pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: Self = ImageLayout(1_000_117_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl ImageLayout {
+    pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: Self = ImageLayout(1_000_117_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const RENDER_PASS_MULTIVIEW_CREATE_INFO: Self = StructureType(1_000_053_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES: Self = StructureType(1_000_053_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: Self = StructureType(1_000_053_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl DependencyFlags {
+    pub const VIEW_LOCAL: Self = DependencyFlags(0b10);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: Self = StructureType(1_000_120_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: Self =
+        StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PROTECTED_SUBMIT_INFO: Self = StructureType(1_000_145_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: Self = StructureType(1_000_145_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: Self = StructureType(1_000_145_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const DEVICE_QUEUE_INFO_2: Self = StructureType(1_000_145_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl QueueFlags {
+    pub const PROTECTED: Self = QueueFlags(0b1_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl DeviceQueueCreateFlags {
+    pub const PROTECTED: Self = DeviceQueueCreateFlags(0b1);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl MemoryPropertyFlags {
+    pub const PROTECTED: Self = MemoryPropertyFlags(0b10_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl BufferCreateFlags {
+    pub const PROTECTED: Self = BufferCreateFlags(0b1000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl ImageCreateFlags {
+    pub const PROTECTED: Self = ImageCreateFlags(0b1000_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl CommandPoolCreateFlags {
+    pub const PROTECTED: Self = CommandPoolCreateFlags(0b100);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO: Self = StructureType(1_000_156_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const SAMPLER_YCBCR_CONVERSION_INFO: Self = StructureType(1_000_156_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const BIND_IMAGE_PLANE_MEMORY_INFO: Self = StructureType(1_000_156_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: Self = StructureType(1_000_156_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: Self =
+        StructureType(1_000_156_004);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: Self = StructureType(1_000_156_005);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl ObjectType {
+    pub const SAMPLER_YCBCR_CONVERSION: Self = ObjectType(1_000_156_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G8B8G8R8_422_UNORM: Self = Format(1_000_156_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const B8G8R8G8_422_UNORM: Self = Format(1_000_156_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G8_B8_R8_3PLANE_420_UNORM: Self = Format(1_000_156_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G8_B8R8_2PLANE_420_UNORM: Self = Format(1_000_156_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G8_B8_R8_3PLANE_422_UNORM: Self = Format(1_000_156_004);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G8_B8R8_2PLANE_422_UNORM: Self = Format(1_000_156_005);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G8_B8_R8_3PLANE_444_UNORM: Self = Format(1_000_156_006);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const R10X6_UNORM_PACK16: Self = Format(1_000_156_007);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const R10X6G10X6_UNORM_2PACK16: Self = Format(1_000_156_008);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16: Self = Format(1_000_156_009);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: Self = Format(1_000_156_010);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: Self = Format(1_000_156_011);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: Self = Format(1_000_156_012);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: Self = Format(1_000_156_013);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: Self = Format(1_000_156_014);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: Self = Format(1_000_156_015);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: Self = Format(1_000_156_016);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const R12X4_UNORM_PACK16: Self = Format(1_000_156_017);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const R12X4G12X4_UNORM_2PACK16: Self = Format(1_000_156_018);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16: Self = Format(1_000_156_019);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: Self = Format(1_000_156_020);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: Self = Format(1_000_156_021);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: Self = Format(1_000_156_022);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: Self = Format(1_000_156_023);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: Self = Format(1_000_156_024);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: Self = Format(1_000_156_025);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: Self = Format(1_000_156_026);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G16B16G16R16_422_UNORM: Self = Format(1_000_156_027);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const B16G16R16G16_422_UNORM: Self = Format(1_000_156_028);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G16_B16_R16_3PLANE_420_UNORM: Self = Format(1_000_156_029);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G16_B16R16_2PLANE_420_UNORM: Self = Format(1_000_156_030);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G16_B16_R16_3PLANE_422_UNORM: Self = Format(1_000_156_031);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G16_B16R16_2PLANE_422_UNORM: Self = Format(1_000_156_032);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Format {
+    pub const G16_B16_R16_3PLANE_444_UNORM: Self = Format(1_000_156_033);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl ImageAspectFlags {
+    pub const PLANE_0: Self = ImageAspectFlags(0b1_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl ImageAspectFlags {
+    pub const PLANE_1: Self = ImageAspectFlags(0b10_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl ImageAspectFlags {
+    pub const PLANE_2: Self = ImageAspectFlags(0b100_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl ImageCreateFlags {
+    pub const DISJOINT: Self = ImageCreateFlags(0b10_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl FormatFeatureFlags {
+    pub const MIDPOINT_CHROMA_SAMPLES: Self = FormatFeatureFlags(0b10_0000_0000_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl FormatFeatureFlags {
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self =
+        FormatFeatureFlags(0b100_0000_0000_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl FormatFeatureFlags {
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self =
+        FormatFeatureFlags(0b1000_0000_0000_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl FormatFeatureFlags {
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self =
+        FormatFeatureFlags(0b1_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl FormatFeatureFlags {
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self =
+        FormatFeatureFlags(0b10_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl FormatFeatureFlags {
+    pub const DISJOINT: Self = FormatFeatureFlags(0b100_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl FormatFeatureFlags {
+    pub const COSITED_CHROMA_SAMPLES: Self = FormatFeatureFlags(0b1000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: Self = StructureType(1_000_085_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl ObjectType {
+    pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = ObjectType(1_000_085_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: Self = StructureType(1_000_071_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES: Self = StructureType(1_000_071_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: Self = StructureType(1_000_071_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const EXTERNAL_BUFFER_PROPERTIES: Self = StructureType(1_000_071_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_ID_PROPERTIES: Self = StructureType(1_000_071_004);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO: Self = StructureType(1_000_072_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO: Self = StructureType(1_000_072_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const EXPORT_MEMORY_ALLOCATE_INFO: Self = StructureType(1_000_072_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl Result {
+    pub const ERROR_INVALID_EXTERNAL_HANDLE: Self = Result(-1_000_072_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: Self = StructureType(1_000_112_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const EXTERNAL_FENCE_PROPERTIES: Self = StructureType(1_000_112_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const EXPORT_FENCE_CREATE_INFO: Self = StructureType(1_000_113_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const EXPORT_SEMAPHORE_CREATE_INFO: Self = StructureType(1_000_077_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: Self = StructureType(1_000_076_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const EXTERNAL_SEMAPHORE_PROPERTIES: Self = StructureType(1_000_076_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: Self = StructureType(1_000_168_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const DESCRIPTOR_SET_LAYOUT_SUPPORT: Self = StructureType(1_000_168_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: Self = StructureType(1_000_063_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_1\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: Self =
+        StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: Self = StructureType(49);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: Self = StructureType(50);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: Self = StructureType(51);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: Self = StructureType(52);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const IMAGE_FORMAT_LIST_CREATE_INFO: Self = StructureType(1_000_147_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const ATTACHMENT_DESCRIPTION_2: Self = StructureType(1_000_109_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const ATTACHMENT_REFERENCE_2: Self = StructureType(1_000_109_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const SUBPASS_DESCRIPTION_2: Self = StructureType(1_000_109_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const SUBPASS_DEPENDENCY_2: Self = StructureType(1_000_109_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const RENDER_PASS_CREATE_INFO_2: Self = StructureType(1_000_109_004);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const SUBPASS_BEGIN_INFO: Self = StructureType(1_000_109_005);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const SUBPASS_END_INFO: Self = StructureType(1_000_109_006);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: Self = StructureType(1_000_177_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES: Self = StructureType(1_000_196_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: Self = StructureType(1_000_180_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: Self = StructureType(1_000_082_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: Self = StructureType(1_000_197_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: Self = StructureType(1_000_161_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: Self = StructureType(1_000_161_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: Self = StructureType(1_000_161_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: Self =
+        StructureType(1_000_161_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: Self =
+        StructureType(1_000_161_004);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl DescriptorPoolCreateFlags {
+    pub const UPDATE_AFTER_BIND: Self = DescriptorPoolCreateFlags(0b10);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl DescriptorSetLayoutCreateFlags {
+    pub const UPDATE_AFTER_BIND_POOL: Self = DescriptorSetLayoutCreateFlags(0b10);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl Result {
+    pub const ERROR_FRAGMENTATION: Self = Result(-1_000_161_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: Self = StructureType(1_000_199_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: Self = StructureType(1_000_199_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: Self = StructureType(1_000_221_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const IMAGE_STENCIL_USAGE_CREATE_INFO: Self = StructureType(1_000_246_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: Self = StructureType(1_000_130_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const SAMPLER_REDUCTION_MODE_CREATE_INFO: Self = StructureType(1_000_130_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl FormatFeatureFlags {
+    pub const SAMPLED_IMAGE_FILTER_MINMAX: Self = FormatFeatureFlags(0b1_0000_0000_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: Self = StructureType(1_000_211_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: Self = StructureType(1_000_108_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: Self = StructureType(1_000_108_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: Self = StructureType(1_000_108_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const RENDER_PASS_ATTACHMENT_BEGIN_INFO: Self = StructureType(1_000_108_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl FramebufferCreateFlags {
+    pub const IMAGELESS: Self = FramebufferCreateFlags(0b1);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: Self =
+        StructureType(1_000_253_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: Self =
+        StructureType(1_000_175_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: Self =
+        StructureType(1_000_241_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT: Self = StructureType(1_000_241_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: Self = StructureType(1_000_241_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl ImageLayout {
+    pub const DEPTH_ATTACHMENT_OPTIMAL: Self = ImageLayout(1_000_241_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl ImageLayout {
+    pub const DEPTH_READ_ONLY_OPTIMAL: Self = ImageLayout(1_000_241_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl ImageLayout {
+    pub const STENCIL_ATTACHMENT_OPTIMAL: Self = ImageLayout(1_000_241_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl ImageLayout {
+    pub const STENCIL_READ_ONLY_OPTIMAL: Self = ImageLayout(1_000_241_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: Self = StructureType(1_000_261_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: Self = StructureType(1_000_207_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: Self = StructureType(1_000_207_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const SEMAPHORE_TYPE_CREATE_INFO: Self = StructureType(1_000_207_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const TIMELINE_SEMAPHORE_SUBMIT_INFO: Self = StructureType(1_000_207_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const SEMAPHORE_WAIT_INFO: Self = StructureType(1_000_207_004);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const SEMAPHORE_SIGNAL_INFO: Self = StructureType(1_000_207_005);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: Self = StructureType(1_000_257_000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const BUFFER_DEVICE_ADDRESS_INFO: Self = StructureType(1_000_244_001);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: Self = StructureType(1_000_257_002);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: Self = StructureType(1_000_257_003);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl StructureType {
+    pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: Self = StructureType(1_000_257_004);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl BufferUsageFlags {
+    pub const SHADER_DEVICE_ADDRESS: Self = BufferUsageFlags(0b10_0000_0000_0000_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl BufferCreateFlags {
+    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = BufferCreateFlags(0b1_0000);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl MemoryAllocateFlags {
+    pub const DEVICE_ADDRESS: Self = MemoryAllocateFlags(0b10);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl MemoryAllocateFlags {
+    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = MemoryAllocateFlags(0b100);
+}
+#[doc = "Generated from \'VK_VERSION_1_2\'"]
+impl Result {
+    pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: Self = Result(-1_000_257_000);
+}

ash/src/vk/macros.rs

@@ -0,0 +1,199 @@
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_MAKE_VERSION.html>"]
+pub const fn make_version(major: u32, minor: u32, patch: u32) -> u32 {
+    (major << 22) | (minor << 12) | patch
+}
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_VERSION_MAJOR.html>"]
+pub const fn version_major(version: u32) -> u32 {
+    version >> 22
+}
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_VERSION_MINOR.html>"]
+pub const fn version_minor(version: u32) -> u32 {
+    (version >> 12) & 0x3ff
+}
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_VERSION_PATCH.html>"]
+pub const fn version_patch(version: u32) -> u32 {
+    version & 0xfff
+}
+#[macro_export]
+macro_rules! vk_bitflags_wrapped {
+    ( $ name : ident , $ all : expr , $ flag_type : ty ) => {
+        impl Default for $name {
+            fn default() -> $name {
+                $name(0)
+            }
+        }
+        impl $name {
+            #[inline]
+            pub const fn empty() -> $name {
+                $name(0)
+            }
+            #[inline]
+            pub const fn all() -> $name {
+                $name($all)
+            }
+            #[inline]
+            pub const fn from_raw(x: $flag_type) -> Self {
+                $name(x)
+            }
+            #[inline]
+            pub const fn as_raw(self) -> $flag_type {
+                self.0
+            }
+            #[inline]
+            pub fn is_empty(self) -> bool {
+                self == $name::empty()
+            }
+            #[inline]
+            pub fn is_all(self) -> bool {
+                self & $name::all() == $name::all()
+            }
+            #[inline]
+            pub fn intersects(self, other: $name) -> bool {
+                self & other != $name::empty()
+            }
+            #[doc = r" Returns whether `other` is a subset of `self`"]
+            #[inline]
+            pub fn contains(self, other: $name) -> bool {
+                self & other == other
+            }
+        }
+        impl ::std::ops::BitOr for $name {
+            type Output = $name;
+            #[inline]
+            fn bitor(self, rhs: $name) -> $name {
+                $name(self.0 | rhs.0)
+            }
+        }
+        impl ::std::ops::BitOrAssign for $name {
+            #[inline]
+            fn bitor_assign(&mut self, rhs: $name) {
+                *self = *self | rhs
+            }
+        }
+        impl ::std::ops::BitAnd for $name {
+            type Output = $name;
+            #[inline]
+            fn bitand(self, rhs: $name) -> $name {
+                $name(self.0 & rhs.0)
+            }
+        }
+        impl ::std::ops::BitAndAssign for $name {
+            #[inline]
+            fn bitand_assign(&mut self, rhs: $name) {
+                *self = *self & rhs
+            }
+        }
+        impl ::std::ops::BitXor for $name {
+            type Output = $name;
+            #[inline]
+            fn bitxor(self, rhs: $name) -> $name {
+                $name(self.0 ^ rhs.0)
+            }
+        }
+        impl ::std::ops::BitXorAssign for $name {
+            #[inline]
+            fn bitxor_assign(&mut self, rhs: $name) {
+                *self = *self ^ rhs
+            }
+        }
+        impl ::std::ops::Sub for $name {
+            type Output = $name;
+            #[inline]
+            fn sub(self, rhs: $name) -> $name {
+                self & !rhs
+            }
+        }
+        impl ::std::ops::SubAssign for $name {
+            #[inline]
+            fn sub_assign(&mut self, rhs: $name) {
+                *self = *self - rhs
+            }
+        }
+        impl ::std::ops::Not for $name {
+            type Output = $name;
+            #[inline]
+            fn not(self) -> $name {
+                self ^ $name::all()
+            }
+        }
+    };
+}
+#[macro_export]
+macro_rules! handle_nondispatchable {
+    ( $ name : ident , $ ty : ident ) => {
+        handle_nondispatchable!($name, $ty, doc = "");
+    };
+    ( $ name : ident , $ ty : ident , $ doc_link : meta ) => {
+        #[repr(transparent)]
+        #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)]
+        #[$doc_link]
+        pub struct $name(u64);
+        impl Handle for $name {
+            const TYPE: ObjectType = ObjectType::$ty;
+            fn as_raw(self) -> u64 {
+                self.0 as u64
+            }
+            fn from_raw(x: u64) -> Self {
+                $name(x as _)
+            }
+        }
+        impl $name {
+            pub const fn null() -> $name {
+                $name(0)
+            }
+        }
+        impl fmt::Pointer for $name {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                write!(f, "0x{:x}", self.0)
+            }
+        }
+        impl fmt::Debug for $name {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                write!(f, "0x{:x}", self.0)
+            }
+        }
+    };
+}
+#[macro_export]
+macro_rules! define_handle {
+    ( $ name : ident , $ ty : ident ) => {
+        define_handle!($name, $ty, doc = "");
+    };
+    ( $ name : ident , $ ty : ident , $ doc_link : meta ) => {
+        #[repr(transparent)]
+        #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash)]
+        #[$doc_link]
+        pub struct $name(*mut u8);
+        impl Default for $name {
+            fn default() -> $name {
+                $name::null()
+            }
+        }
+        impl Handle for $name {
+            const TYPE: ObjectType = ObjectType::$ty;
+            fn as_raw(self) -> u64 {
+                self.0 as u64
+            }
+            fn from_raw(x: u64) -> Self {
+                $name(x as _)
+            }
+        }
+        unsafe impl Send for $name {}
+        unsafe impl Sync for $name {}
+        impl $name {
+            pub const fn null() -> Self {
+                $name(::std::ptr::null_mut())
+            }
+        }
+        impl fmt::Pointer for $name {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                fmt::Pointer::fmt(&self.0, f)
+            }
+        }
+        impl fmt::Debug for $name {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                fmt::Debug::fmt(&self.0, f)
+            }
+        }
+    };
+}

ash/src/vk/platform_types.rs

@@ -0,0 +1,34 @@
+use std::os::raw::*;
+pub type RROutput = c_ulong;
+pub type VisualID = c_uint;
+pub type Display = *const c_void;
+pub type Window = c_ulong;
+#[allow(non_camel_case_types)]
+pub type xcb_connection_t = c_void;
+#[allow(non_camel_case_types)]
+pub type xcb_window_t = u32;
+#[allow(non_camel_case_types)]
+pub type xcb_visualid_t = u32;
+pub type MirConnection = *const c_void;
+pub type MirSurface = *const c_void;
+pub type HINSTANCE = *const c_void;
+pub type HWND = *const c_void;
+#[allow(non_camel_case_types)]
+pub type wl_display = c_void;
+#[allow(non_camel_case_types)]
+pub type wl_surface = c_void;
+pub type HANDLE = *mut c_void;
+pub type HMONITOR = HANDLE;
+pub type DWORD = c_ulong;
+pub type LPCWSTR = *const u16;
+#[allow(non_camel_case_types)]
+pub type zx_handle_t = u32;
+#[allow(non_camel_case_types)]
+pub type SECURITY_ATTRIBUTES = ();
+pub type ANativeWindow = c_void;
+pub type AHardwareBuffer = c_void;
+#[doc = r" This definition is experimental and won't adhere to semver rules."]
+pub type GgpStreamDescriptor = u32;
+#[doc = r" This definition is experimental and won't adhere to semver rules."]
+pub type GgpFrameToken = u32;
+pub type CAMetalLayer = c_void;

generator/src/bin/generator.rs

@@ -2,5 +2,13 @@ use generator::write_source_code;
 use std::path::Path;
 
 fn main() {
-    write_source_code(Path::new("Vulkan-Headers/registry/vk.xml"));
+    let cwd = std::env::current_dir().unwrap();
+    if cwd.ends_with("generator") {
+        write_source_code(Path::new("Vulkan-Headers/registry/vk.xml"), "../ash/src");
+    } else {
+        write_source_code(
+            Path::new("generator/Vulkan-Headers/registry/vk.xml"),
+            "ash/src",
+        );
+    }
 }

generator/src/lib.rs

@@ -1158,7 +1158,7 @@ pub fn generate_bitmask(
         #[repr(transparent)]
         #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
         #[doc = #khronos_link]
-        pub struct #ident(Flags);
+        pub struct #ident(pub(crate) Flags);
         vk_bitflags_wrapped!(#ident, 0b0, Flags);
     })
 }
@@ -2258,10 +2258,10 @@ pub fn generate_aliases_of_types<'a>(
         #(#aliases)*
     }
 }
-pub fn write_source_code(path: &Path) {
+pub fn write_source_code<P: AsRef<Path>>(vk_xml: &Path, src_dir: P) {
     use std::fs::File;
     use std::io::Write;
-    let spec2 = vk_parse::parse_file(path);
+    let spec2 = vk_parse::parse_file(vk_xml);
     let extensions: &Vec<vk_parse::Extension> = spec2
         .0
         .iter()
@@ -2283,7 +2283,7 @@ pub fn write_source_code(path: &Path) {
         })
         .collect();
 
-    let spec = vk_parse::parse_file_as_vkxml(path);
+    let spec = vk_parse::parse_file_as_vkxml(vk_xml);
     let cmd_aliases: HashMap<String, String> = spec2
         .0
         .iter()
@@ -2426,16 +2426,13 @@ pub fn write_source_code(path: &Path) {
 
     let const_debugs = generate_const_debugs(&const_values);
 
-    let mut file = File::create("../ash/src/vk.rs").expect("vk");
     let bitflags_macro = vk_bitflags_wrapped_macro();
     let handle_nondispatchable_macro = handle_nondispatchable_macro();
     let define_handle_macro = define_handle_macro();
     let version_macros = vk_version_macros();
     let platform_specific_types = platform_specific_types();
-    let source_code = quote! {
+
-        #![allow(clippy::too_many_arguments, clippy::cognitive_complexity, clippy::wrong_self_convention)]
+    let ptr_chain_code = quote! {
-        use std::fmt;
-        use std::os::raw::*;
         /// Iterates through the pointer chain. Includes the item that is passed into the function.
         /// Stops at the last `BaseOutStructure` that has a null `p_next` field.
         pub(crate) unsafe fn ptr_chain_iter<T>(
@@ -2452,27 +2449,170 @@ pub fn write_source_code(path: &Path) {
                 Some(old)
             })
         }
+    };
+
+    let macros_code = quote! {
+        #version_macros
+        #bitflags_macro
+        #handle_nondispatchable_macro
+        #define_handle_macro
+    };
+
+    let src_dir = src_dir.as_ref();
+
+    let vk_dir = src_dir.join("vk");
+    std::fs::create_dir_all(&vk_dir).expect("failed to create vk dir");
+
+    let mut vk_rs_file = File::create(src_dir.join("vk.rs")).expect("vk.rs");
+
+    let mut vk_macros_file = File::create(vk_dir.join("macros.rs")).expect("vk/macros.rs");
+    let mut vk_features_file = File::create(vk_dir.join("features.rs")).expect("vk/features.rs");
+    let mut vk_definitions_file =
+        File::create(vk_dir.join("definitions.rs")).expect("vk/definitions.rs");
+    let mut vk_platform_types_file =
+        File::create(vk_dir.join("platform_types.rs")).expect("vk/platform_types.rs");
+    let mut vk_enums_file = File::create(vk_dir.join("enums.rs")).expect("vk/enums.rs");
+    let mut vk_bitflags_file = File::create(vk_dir.join("bitflags.rs")).expect("vk/bitflags.rs");
+    let mut vk_constants_file = File::create(vk_dir.join("constants.rs")).expect("vk/constants.rs");
+    let mut vk_extensions_file =
+        File::create(vk_dir.join("extensions.rs")).expect("vk/extensions.rs");
+    let mut vk_feature_extensions_file =
+        File::create(vk_dir.join("feature_extensions.rs")).expect("vk/feature_extensions.rs");
+    let mut vk_const_debugs_file =
+        File::create(vk_dir.join("const_debugs.rs")).expect("vk/const_debugs.rs");
+    let mut vk_aliases_file = File::create(vk_dir.join("aliases.rs")).expect("vk/aliases.rs");
+
+    let feature_code = quote! {
+        use std::os::raw::*;
+        use crate::vk::bitflags::*;
+        use crate::vk::definitions::*;
+        use crate::vk::enums::*;
+        #(#feature_code)*
+    };
+
+    let definition_code = quote! {
+        use std::fmt;
+        use std::os::raw::*;
+        use crate::vk::{Handle, ptr_chain_iter};
+        use crate::vk::platform_types::*;
+        use crate::vk::aliases::*;
+        use crate::vk::bitflags::*;
+        use crate::vk::constants::*;
+        use crate::vk::enums::*;
+        #(#definition_code)*
+    };
+
+    let enum_code = quote! {
+        use std::fmt;
+        #(#enum_code)*
+    };
+
+    let bitflags_code = quote! {
+        use crate::vk::definitions::*;
+        #(#bitflags_code)*
+    };
+
+    let constants_code = quote! {
+        use crate::vk::definitions::*;
+        #(#constants_code)*
+    };
+
+    let extension_code = quote! {
+        use std::os::raw::*;
+        use crate::vk::platform_types::*;
+        use crate::vk::aliases::*;
+        use crate::vk::bitflags::*;
+        use crate::vk::definitions::*;
+        use crate::vk::enums::*;
+        #(#extension_code)*
+    };
+
+    let feature_extensions_code = quote! {
+        use crate::vk::bitflags::*;
+        use crate::vk::enums::*;
+       #feature_extensions_code
+    };
+
+    let const_debugs = quote! {
+        use std::fmt;
+        use crate::vk::bitflags::*;
+        use crate::vk::definitions::*;
+        use crate::vk::enums::*;
+        #const_debugs
+    };
+
+    let aliases = quote! {
+        use crate::vk::bitflags::*;
+        use crate::vk::definitions::*;
+        use crate::vk::enums::*;
+        #(#aliases)*
+    };
+
+    let platform_types_code = quote! {
+        use std::os::raw::*;
+        #platform_specific_types
+    };
+
+    // These are defined outside of `quote!` because rustfmt doesn't seem
+    // to format them correctly when they contain extra spaces.
+    let vk_rs_clippy_lints = r#"
+#![allow(clippy::too_many_arguments, clippy::cognitive_complexity, clippy::wrong_self_convention)]
+"#;
+
+    let vk_rs_code = quote! {
+        #[macro_use]
+        mod macros;
+        pub use macros::*;
+        mod aliases;
+        pub use aliases::*;
+        mod bitflags;
+        pub use bitflags::*;
+        mod const_debugs;
+        pub(crate) use const_debugs::*;
+        mod constants;
+        pub use constants::*;
+        mod definitions;
+        pub use definitions::*;
+        mod enums;
+        pub use enums::*;
+        mod extensions;
+        pub use extensions::*;
+        mod feature_extensions;
+        pub use feature_extensions::*;
+        mod features;
+        pub use features::*;
+        mod platform_types;
+        pub use platform_types::*;
+
+        #ptr_chain_code
 
         pub trait Handle {
             const TYPE: ObjectType;
             fn as_raw(self) -> u64;
             fn from_raw(_: u64) -> Self;
         }
-
-        #version_macros
-        #platform_specific_types
-        #bitflags_macro
-        #handle_nondispatchable_macro
-        #define_handle_macro
-        #(#feature_code)*
-        #(#definition_code)*
-        #(#enum_code)*
-        #(#bitflags_code)*
-        #(#constants_code)*
-        #(#extension_code)*
-        #feature_extensions_code
-        #const_debugs
-        #(#aliases)*
     };
-    write!(&mut file, "{}", source_code).expect("Unable to write to file");
+
+    write!(&mut vk_macros_file, "{}", macros_code).expect("Unable to write vk/macros.rs");
+    write!(&mut vk_platform_types_file, "{}", platform_types_code)
+        .expect("Unable to write to vk/platform_types.rs");
+    write!(&mut vk_features_file, "{}", feature_code).expect("Unable to write vk/features.rs");
+    write!(&mut vk_definitions_file, "{}", definition_code)
+        .expect("Unable to write vk/definitions.rs");
+    write!(&mut vk_enums_file, "{}", enum_code).expect("Unable to write vk/enums.rs");
+    write!(&mut vk_bitflags_file, "{}", bitflags_code).expect("Unable to write vk/bitflags.rs");
+    write!(&mut vk_constants_file, "{}", constants_code).expect("Unable to write vk/constants.rs");
+    write!(&mut vk_extensions_file, "{}", extension_code)
+        .expect("Unable to write vk/extensions.rs");
+    write!(
+        &mut vk_feature_extensions_file,
+        "{}",
+        feature_extensions_code
+    )
+    .expect("Unable to write vk/feature_extensions.rs");
+    write!(&mut vk_const_debugs_file, "{}", const_debugs)
+        .expect("Unable to write vk/const_debugs.rs");
+    write!(&mut vk_aliases_file, "{}", aliases).expect("Unable to write vk/aliases.rs");
+    write!(&mut vk_rs_file, "{} {}", vk_rs_clippy_lints, vk_rs_code)
+        .expect("Unable to write vk.rs");
 }