alex/ash
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

vk: Remove misleading all()/-/-= function/ops from bitflags (#478)

Browse source 
The `all()` function only represents bitflags known in the core of
Vulkan; it omits all bits added by extensions making this function
unrepresentative and has hence been scheduled for removal for quite some
time to get rid of the confusion it causes.

Alternatively the generator could be taught to collect bitflags added by
extensions, but new extensions get added over time skewing available
values in ash versus the current driver/environment.  This makes the
value from `all()` unreliable and fragile at best.

`-` and `-=` (`sub()` and `sub_assign()`) are also controversial by
nature since the underlying value represents an integer but the
implemented math uses bitwise operators.  This is a confusing design
pattern and the caller better replaces their uses - if any at all - with
`foo &= !BAR`.
This commit is contained in:
Marijn Suijten 2021-11-10 00:35:35 +01:00 committed by GitHub
parent 6857f7b4d3
commit c4dd1d6040
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 183 additions and 255 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
ash/src/extensions/experimental/amd.rs
View file

@ -34,11 +34,7 @@ use std::os::raw::*;
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct GpaSqShaderStageFlags(pub(crate) Flags); pub struct GpaSqShaderStageFlags(pub(crate) Flags);
vk_bitflags_wrapped!( vk_bitflags_wrapped!(GpaSqShaderStageFlags, Flags);
GpaSqShaderStageFlags,
0b1111111111111111111111111111111,
Flags
);
impl fmt::Debug for GpaSqShaderStageFlags { impl fmt::Debug for GpaSqShaderStageFlags {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
const KNOWN: &[(Flags, &str)] = &[ const KNOWN: &[(Flags, &str)] = &[

236
ash/src/vk/bitflags.rs
View file

@ -3,13 +3,13 @@ use crate::vk::definitions::*;
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCacheCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCacheCreateFlagBits.html>"]
pub struct PipelineCacheCreateFlags(pub(crate) Flags); pub struct PipelineCacheCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineCacheCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(PipelineCacheCreateFlags, Flags);
impl PipelineCacheCreateFlags {} impl PipelineCacheCreateFlags {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFlagBits.html>"]
pub struct QueueFlags(pub(crate) Flags); pub struct QueueFlags(pub(crate) Flags);
vk_bitflags_wrapped!(QueueFlags, 0b1111, Flags); vk_bitflags_wrapped!(QueueFlags, Flags);
impl QueueFlags { impl QueueFlags {
#[doc = "Queue supports graphics operations"] #[doc = "Queue supports graphics operations"]
pub const GRAPHICS: Self = Self(0b1); pub const GRAPHICS: Self = Self(0b1);
@ -24,7 +24,7 @@ impl QueueFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCullModeFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCullModeFlagBits.html>"]
pub struct CullModeFlags(pub(crate) Flags); pub struct CullModeFlags(pub(crate) Flags);
vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags); vk_bitflags_wrapped!(CullModeFlags, Flags);
impl CullModeFlags { impl CullModeFlags {
pub const NONE: Self = Self(0); pub const NONE: Self = Self(0);
pub const FRONT: Self = Self(0b1); pub const FRONT: Self = Self(0b1);
@ -35,19 +35,19 @@ impl CullModeFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassCreateFlagBits.html>"]
pub struct RenderPassCreateFlags(pub(crate) Flags); pub struct RenderPassCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(RenderPassCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(RenderPassCreateFlags, Flags);
impl RenderPassCreateFlags {} impl RenderPassCreateFlags {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueCreateFlagBits.html>"]
pub struct DeviceQueueCreateFlags(pub(crate) Flags); pub struct DeviceQueueCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(DeviceQueueCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(DeviceQueueCreateFlags, Flags);
impl DeviceQueueCreateFlags {} impl DeviceQueueCreateFlags {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryPropertyFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryPropertyFlagBits.html>"]
pub struct MemoryPropertyFlags(pub(crate) Flags); pub struct MemoryPropertyFlags(pub(crate) Flags);
vk_bitflags_wrapped!(MemoryPropertyFlags, 0b1_1111, Flags); vk_bitflags_wrapped!(MemoryPropertyFlags, Flags);
impl MemoryPropertyFlags { impl MemoryPropertyFlags {
#[doc = "If otherwise stated, then allocate memory on device"] #[doc = "If otherwise stated, then allocate memory on device"]
pub const DEVICE_LOCAL: Self = Self(0b1); pub const DEVICE_LOCAL: Self = Self(0b1);
@ -64,7 +64,7 @@ impl MemoryPropertyFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryHeapFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryHeapFlagBits.html>"]
pub struct MemoryHeapFlags(pub(crate) Flags); pub struct MemoryHeapFlags(pub(crate) Flags);
vk_bitflags_wrapped!(MemoryHeapFlags, 0b1, Flags); vk_bitflags_wrapped!(MemoryHeapFlags, Flags);
impl MemoryHeapFlags { impl MemoryHeapFlags {
#[doc = "If set, heap represents device memory"] #[doc = "If set, heap represents device memory"]
pub const DEVICE_LOCAL: Self = Self(0b1); pub const DEVICE_LOCAL: Self = Self(0b1);
@ -73,7 +73,7 @@ impl MemoryHeapFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccessFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccessFlagBits.html>"]
pub struct AccessFlags(pub(crate) Flags); pub struct AccessFlags(pub(crate) Flags);
vk_bitflags_wrapped!(AccessFlags, 0b1_1111_1111_1111_1111, Flags); vk_bitflags_wrapped!(AccessFlags, Flags);
impl AccessFlags { impl AccessFlags {
#[doc = "Controls coherency of indirect command reads"] #[doc = "Controls coherency of indirect command reads"]
pub const INDIRECT_COMMAND_READ: Self = Self(0b1); pub const INDIRECT_COMMAND_READ: Self = Self(0b1);
@ -114,7 +114,7 @@ impl AccessFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferUsageFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferUsageFlagBits.html>"]
pub struct BufferUsageFlags(pub(crate) Flags); pub struct BufferUsageFlags(pub(crate) Flags);
vk_bitflags_wrapped!(BufferUsageFlags, 0b1_1111_1111, Flags); vk_bitflags_wrapped!(BufferUsageFlags, Flags);
impl BufferUsageFlags { impl BufferUsageFlags {
#[doc = "Can be used as a source of transfer operations"] #[doc = "Can be used as a source of transfer operations"]
pub const TRANSFER_SRC: Self = Self(0b1); pub const TRANSFER_SRC: Self = Self(0b1);
@ -139,7 +139,7 @@ impl BufferUsageFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferCreateFlagBits.html>"]
pub struct BufferCreateFlags(pub(crate) Flags); pub struct BufferCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(BufferCreateFlags, 0b111, Flags); vk_bitflags_wrapped!(BufferCreateFlags, Flags);
impl BufferCreateFlags { impl BufferCreateFlags {
#[doc = "Buffer should support sparse backing"] #[doc = "Buffer should support sparse backing"]
pub const SPARSE_BINDING: Self = Self(0b1); pub const SPARSE_BINDING: Self = Self(0b1);
@ -152,11 +152,7 @@ impl BufferCreateFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderStageFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderStageFlagBits.html>"]
pub struct ShaderStageFlags(pub(crate) Flags); pub struct ShaderStageFlags(pub(crate) Flags);
vk_bitflags_wrapped!( vk_bitflags_wrapped!(ShaderStageFlags, Flags);
ShaderStageFlags,
0b111_1111_1111_1111_1111_1111_1111_1111,
Flags
);
impl ShaderStageFlags { impl ShaderStageFlags {
pub const VERTEX: Self = Self(0b1); pub const VERTEX: Self = Self(0b1);
pub const TESSELLATION_CONTROL: Self = Self(0b10); pub const TESSELLATION_CONTROL: Self = Self(0b10);
@ -171,7 +167,7 @@ impl ShaderStageFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageUsageFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageUsageFlagBits.html>"]
pub struct ImageUsageFlags(pub(crate) Flags); pub struct ImageUsageFlags(pub(crate) Flags);
vk_bitflags_wrapped!(ImageUsageFlags, 0b1111_1111, Flags); vk_bitflags_wrapped!(ImageUsageFlags, Flags);
impl ImageUsageFlags { impl ImageUsageFlags {
#[doc = "Can be used as a source of transfer operations"] #[doc = "Can be used as a source of transfer operations"]
pub const TRANSFER_SRC: Self = Self(0b1); pub const TRANSFER_SRC: Self = Self(0b1);
@ -194,7 +190,7 @@ impl ImageUsageFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageCreateFlagBits.html>"]
pub struct ImageCreateFlags(pub(crate) Flags); pub struct ImageCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(ImageCreateFlags, 0b1_1111, Flags); vk_bitflags_wrapped!(ImageCreateFlags, Flags);
impl ImageCreateFlags { impl ImageCreateFlags {
#[doc = "Image should support sparse backing"] #[doc = "Image should support sparse backing"]
pub const SPARSE_BINDING: Self = Self(0b1); pub const SPARSE_BINDING: Self = Self(0b1);
@ -211,19 +207,19 @@ impl ImageCreateFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewCreateFlagBits.html>"]
pub struct ImageViewCreateFlags(pub(crate) Flags); pub struct ImageViewCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(ImageViewCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(ImageViewCreateFlags, Flags);
impl ImageViewCreateFlags {} impl ImageViewCreateFlags {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerCreateFlagBits.html>"]
pub struct SamplerCreateFlags(pub(crate) Flags); pub struct SamplerCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(SamplerCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(SamplerCreateFlags, Flags);
impl SamplerCreateFlags {} impl SamplerCreateFlags {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreateFlagBits.html>"]
pub struct PipelineCreateFlags(pub(crate) Flags); pub struct PipelineCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineCreateFlags, 0b111, Flags); vk_bitflags_wrapped!(PipelineCreateFlags, Flags);
impl PipelineCreateFlags { impl PipelineCreateFlags {
pub const DISABLE_OPTIMIZATION: Self = Self(0b1); pub const DISABLE_OPTIMIZATION: Self = Self(0b1);
pub const ALLOW_DERIVATIVES: Self = Self(0b10); pub const ALLOW_DERIVATIVES: Self = Self(0b10);
@ -233,13 +229,13 @@ impl PipelineCreateFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineShaderStageCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineShaderStageCreateFlagBits.html>"]
pub struct PipelineShaderStageCreateFlags(pub(crate) Flags); pub struct PipelineShaderStageCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, Flags);
impl PipelineShaderStageCreateFlags {} impl PipelineShaderStageCreateFlags {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkColorComponentFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkColorComponentFlagBits.html>"]
pub struct ColorComponentFlags(pub(crate) Flags); pub struct ColorComponentFlags(pub(crate) Flags);
vk_bitflags_wrapped!(ColorComponentFlags, 0b1111, Flags); vk_bitflags_wrapped!(ColorComponentFlags, Flags);
impl ColorComponentFlags { impl ColorComponentFlags {
pub const R: Self = Self(0b1); pub const R: Self = Self(0b1);
pub const G: Self = Self(0b10); pub const G: Self = Self(0b10);
@ -250,7 +246,7 @@ impl ColorComponentFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceCreateFlagBits.html>"]
pub struct FenceCreateFlags(pub(crate) Flags); pub struct FenceCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(FenceCreateFlags, 0b1, Flags); vk_bitflags_wrapped!(FenceCreateFlags, Flags);
impl FenceCreateFlags { impl FenceCreateFlags {
pub const SIGNALED: Self = Self(0b1); pub const SIGNALED: Self = Self(0b1);
} }
@ -258,13 +254,13 @@ impl FenceCreateFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreCreateFlagBits.html>"]
pub struct SemaphoreCreateFlags(pub(crate) Flags); pub struct SemaphoreCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(SemaphoreCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(SemaphoreCreateFlags, Flags);
impl SemaphoreCreateFlags {} impl SemaphoreCreateFlags {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatFeatureFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatFeatureFlagBits.html>"]
pub struct FormatFeatureFlags(pub(crate) Flags); pub struct FormatFeatureFlags(pub(crate) Flags);
vk_bitflags_wrapped!(FormatFeatureFlags, 0b1_1111_1111_1111, Flags); vk_bitflags_wrapped!(FormatFeatureFlags, Flags);
impl FormatFeatureFlags { impl FormatFeatureFlags {
#[doc = "Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] #[doc = "Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"]
pub const SAMPLED_IMAGE: Self = Self(0b1); pub const SAMPLED_IMAGE: Self = Self(0b1);
@ -297,7 +293,7 @@ impl FormatFeatureFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryControlFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryControlFlagBits.html>"]
pub struct QueryControlFlags(pub(crate) Flags); pub struct QueryControlFlags(pub(crate) Flags);
vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags); vk_bitflags_wrapped!(QueryControlFlags, Flags);
impl QueryControlFlags { impl QueryControlFlags {
#[doc = "Require precise results to be collected by the query"] #[doc = "Require precise results to be collected by the query"]
pub const PRECISE: Self = Self(0b1); pub const PRECISE: Self = Self(0b1);
@ -306,7 +302,7 @@ impl QueryControlFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryResultFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryResultFlagBits.html>"]
pub struct QueryResultFlags(pub(crate) Flags); pub struct QueryResultFlags(pub(crate) Flags);
vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags); vk_bitflags_wrapped!(QueryResultFlags, Flags);
impl QueryResultFlags { impl QueryResultFlags {
#[doc = "Results of the queries are written to the destination buffer as 64-bit values"] #[doc = "Results of the queries are written to the destination buffer as 64-bit values"]
pub const TYPE_64: Self = Self(0b1); pub const TYPE_64: Self = Self(0b1);
@ -321,7 +317,7 @@ impl QueryResultFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferUsageFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferUsageFlagBits.html>"]
pub struct CommandBufferUsageFlags(pub(crate) Flags); pub struct CommandBufferUsageFlags(pub(crate) Flags);
vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags); vk_bitflags_wrapped!(CommandBufferUsageFlags, Flags);
impl CommandBufferUsageFlags { impl CommandBufferUsageFlags {
pub const ONE_TIME_SUBMIT: Self = Self(0b1); pub const ONE_TIME_SUBMIT: Self = Self(0b1);
pub const RENDER_PASS_CONTINUE: Self = Self(0b10); pub const RENDER_PASS_CONTINUE: Self = Self(0b10);
@ -332,7 +328,7 @@ impl CommandBufferUsageFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPipelineStatisticFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPipelineStatisticFlagBits.html>"]
pub struct QueryPipelineStatisticFlags(pub(crate) Flags); pub struct QueryPipelineStatisticFlags(pub(crate) Flags);
vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b111_1111_1111, Flags); vk_bitflags_wrapped!(QueryPipelineStatisticFlags, Flags);
impl QueryPipelineStatisticFlags { impl QueryPipelineStatisticFlags {
#[doc = "Optional"] #[doc = "Optional"]
pub const INPUT_ASSEMBLY_VERTICES: Self = Self(0b1); pub const INPUT_ASSEMBLY_VERTICES: Self = Self(0b1);
@ -361,7 +357,7 @@ impl QueryPipelineStatisticFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageAspectFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageAspectFlagBits.html>"]
pub struct ImageAspectFlags(pub(crate) Flags); pub struct ImageAspectFlags(pub(crate) Flags);
vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags); vk_bitflags_wrapped!(ImageAspectFlags, Flags);
impl ImageAspectFlags { impl ImageAspectFlags {
pub const COLOR: Self = Self(0b1); pub const COLOR: Self = Self(0b1);
pub const DEPTH: Self = Self(0b10); pub const DEPTH: Self = Self(0b10);
@ -372,7 +368,7 @@ impl ImageAspectFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageFormatFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageFormatFlagBits.html>"]
pub struct SparseImageFormatFlags(pub(crate) Flags); pub struct SparseImageFormatFlags(pub(crate) Flags);
vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags); vk_bitflags_wrapped!(SparseImageFormatFlags, Flags);
impl SparseImageFormatFlags { impl SparseImageFormatFlags {
#[doc = "Image uses a single mip tail region for all array layers"] #[doc = "Image uses a single mip tail region for all array layers"]
pub const SINGLE_MIPTAIL: Self = Self(0b1); pub const SINGLE_MIPTAIL: Self = Self(0b1);
@ -385,7 +381,7 @@ impl SparseImageFormatFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseMemoryBindFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseMemoryBindFlagBits.html>"]
pub struct SparseMemoryBindFlags(pub(crate) Flags); pub struct SparseMemoryBindFlags(pub(crate) Flags);
vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags); vk_bitflags_wrapped!(SparseMemoryBindFlags, Flags);
impl SparseMemoryBindFlags { impl SparseMemoryBindFlags {
#[doc = "Operation binds resource metadata to memory"] #[doc = "Operation binds resource metadata to memory"]
pub const METADATA: Self = Self(0b1); pub const METADATA: Self = Self(0b1);
@ -394,7 +390,7 @@ impl SparseMemoryBindFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineStageFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineStageFlagBits.html>"]
pub struct PipelineStageFlags(pub(crate) Flags); pub struct PipelineStageFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineStageFlags, 0b1_1111_1111_1111_1111, Flags); vk_bitflags_wrapped!(PipelineStageFlags, Flags);
impl PipelineStageFlags { impl PipelineStageFlags {
#[doc = "Before subsequent commands are processed"] #[doc = "Before subsequent commands are processed"]
pub const TOP_OF_PIPE: Self = Self(0b1); pub const TOP_OF_PIPE: Self = Self(0b1);
@ -435,7 +431,7 @@ impl PipelineStageFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolCreateFlagBits.html>"]
pub struct CommandPoolCreateFlags(pub(crate) Flags); pub struct CommandPoolCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags); vk_bitflags_wrapped!(CommandPoolCreateFlags, Flags);
impl CommandPoolCreateFlags { impl CommandPoolCreateFlags {
#[doc = "Command buffers have a short lifetime"] #[doc = "Command buffers have a short lifetime"]
pub const TRANSIENT: Self = Self(0b1); pub const TRANSIENT: Self = Self(0b1);
@ -446,7 +442,7 @@ impl CommandPoolCreateFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolResetFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolResetFlagBits.html>"]
pub struct CommandPoolResetFlags(pub(crate) Flags); pub struct CommandPoolResetFlags(pub(crate) Flags);
vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags); vk_bitflags_wrapped!(CommandPoolResetFlags, Flags);
impl CommandPoolResetFlags { impl CommandPoolResetFlags {
#[doc = "Release resources owned by the pool"] #[doc = "Release resources owned by the pool"]
pub const RELEASE_RESOURCES: Self = Self(0b1); pub const RELEASE_RESOURCES: Self = Self(0b1);
@ -455,7 +451,7 @@ impl CommandPoolResetFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferResetFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferResetFlagBits.html>"]
pub struct CommandBufferResetFlags(pub(crate) Flags); pub struct CommandBufferResetFlags(pub(crate) Flags);
vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags); vk_bitflags_wrapped!(CommandBufferResetFlags, Flags);
impl CommandBufferResetFlags { impl CommandBufferResetFlags {
#[doc = "Release resources owned by the buffer"] #[doc = "Release resources owned by the buffer"]
pub const RELEASE_RESOURCES: Self = Self(0b1); pub const RELEASE_RESOURCES: Self = Self(0b1);
@ -464,7 +460,7 @@ impl CommandBufferResetFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleCountFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleCountFlagBits.html>"]
pub struct SampleCountFlags(pub(crate) Flags); pub struct SampleCountFlags(pub(crate) Flags);
vk_bitflags_wrapped!(SampleCountFlags, 0b111_1111, Flags); vk_bitflags_wrapped!(SampleCountFlags, Flags);
impl SampleCountFlags { impl SampleCountFlags {
#[doc = "Sample count 1 supported"] #[doc = "Sample count 1 supported"]
pub const TYPE_1: Self = Self(0b1); pub const TYPE_1: Self = Self(0b1);
@ -485,7 +481,7 @@ impl SampleCountFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescriptionFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescriptionFlagBits.html>"]
pub struct AttachmentDescriptionFlags(pub(crate) Flags); pub struct AttachmentDescriptionFlags(pub(crate) Flags);
vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags); vk_bitflags_wrapped!(AttachmentDescriptionFlags, Flags);
impl AttachmentDescriptionFlags { impl AttachmentDescriptionFlags {
#[doc = "The attachment may alias physical memory of another attachment in the same render pass"] #[doc = "The attachment may alias physical memory of another attachment in the same render pass"]
pub const MAY_ALIAS: Self = Self(0b1); pub const MAY_ALIAS: Self = Self(0b1);
@ -494,7 +490,7 @@ impl AttachmentDescriptionFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStencilFaceFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStencilFaceFlagBits.html>"]
pub struct StencilFaceFlags(pub(crate) Flags); pub struct StencilFaceFlags(pub(crate) Flags);
vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags); vk_bitflags_wrapped!(StencilFaceFlags, Flags);
impl StencilFaceFlags { impl StencilFaceFlags {
#[doc = "Front face"] #[doc = "Front face"]
pub const FRONT: Self = Self(0b1); pub const FRONT: Self = Self(0b1);
@ -509,7 +505,7 @@ impl StencilFaceFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolCreateFlagBits.html>"]
pub struct DescriptorPoolCreateFlags(pub(crate) Flags); pub struct DescriptorPoolCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags); vk_bitflags_wrapped!(DescriptorPoolCreateFlags, Flags);
impl DescriptorPoolCreateFlags { impl DescriptorPoolCreateFlags {
#[doc = "Descriptor sets may be freed individually"] #[doc = "Descriptor sets may be freed individually"]
pub const FREE_DESCRIPTOR_SET: Self = Self(0b1); pub const FREE_DESCRIPTOR_SET: Self = Self(0b1);
@ -518,7 +514,7 @@ impl DescriptorPoolCreateFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDependencyFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDependencyFlagBits.html>"]
pub struct DependencyFlags(pub(crate) Flags); pub struct DependencyFlags(pub(crate) Flags);
vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags); vk_bitflags_wrapped!(DependencyFlags, Flags);
impl DependencyFlags { impl DependencyFlags {
#[doc = "Dependency is per pixel region "] #[doc = "Dependency is per pixel region "]
pub const BY_REGION: Self = Self(0b1); pub const BY_REGION: Self = Self(0b1);
@ -527,7 +523,7 @@ impl DependencyFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreWaitFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreWaitFlagBits.html>"]
pub struct SemaphoreWaitFlags(pub(crate) Flags); pub struct SemaphoreWaitFlags(pub(crate) Flags);
vk_bitflags_wrapped!(SemaphoreWaitFlags, 0b1, Flags); vk_bitflags_wrapped!(SemaphoreWaitFlags, Flags);
impl SemaphoreWaitFlags { impl SemaphoreWaitFlags {
pub const ANY: Self = Self(0b1); pub const ANY: Self = Self(0b1);
} }
@ -535,7 +531,7 @@ impl SemaphoreWaitFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneAlphaFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneAlphaFlagBitsKHR.html>"]
pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags); pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags); vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, Flags);
impl DisplayPlaneAlphaFlagsKHR { impl DisplayPlaneAlphaFlagsKHR {
pub const OPAQUE: Self = Self(0b1); pub const OPAQUE: Self = Self(0b1);
pub const GLOBAL: Self = Self(0b10); pub const GLOBAL: Self = Self(0b10);
@ -546,7 +542,7 @@ impl DisplayPlaneAlphaFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCompositeAlphaFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCompositeAlphaFlagBitsKHR.html>"]
pub struct CompositeAlphaFlagsKHR(pub(crate) Flags); pub struct CompositeAlphaFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags); vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, Flags);
impl CompositeAlphaFlagsKHR { impl CompositeAlphaFlagsKHR {
pub const OPAQUE: Self = Self(0b1); pub const OPAQUE: Self = Self(0b1);
pub const PRE_MULTIPLIED: Self = Self(0b10); pub const PRE_MULTIPLIED: Self = Self(0b10);
@ -557,7 +553,7 @@ impl CompositeAlphaFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceTransformFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceTransformFlagBitsKHR.html>"]
pub struct SurfaceTransformFlagsKHR(pub(crate) Flags); pub struct SurfaceTransformFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b1_1111_1111, Flags); vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, Flags);
impl SurfaceTransformFlagsKHR { impl SurfaceTransformFlagsKHR {
pub const IDENTITY: Self = Self(0b1); pub const IDENTITY: Self = Self(0b1);
pub const ROTATE_90: Self = Self(0b10); pub const ROTATE_90: Self = Self(0b10);
@ -573,7 +569,7 @@ impl SurfaceTransformFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainImageUsageFlagBitsANDROID.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainImageUsageFlagBitsANDROID.html>"]
pub struct SwapchainImageUsageFlagsANDROID(pub(crate) Flags); pub struct SwapchainImageUsageFlagsANDROID(pub(crate) Flags);
vk_bitflags_wrapped!(SwapchainImageUsageFlagsANDROID, 0b1, Flags); vk_bitflags_wrapped!(SwapchainImageUsageFlagsANDROID, Flags);
impl SwapchainImageUsageFlagsANDROID { impl SwapchainImageUsageFlagsANDROID {
pub const SHARED: Self = Self(0b1); pub const SHARED: Self = Self(0b1);
} }
@ -581,7 +577,7 @@ impl SwapchainImageUsageFlagsANDROID {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugReportFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugReportFlagBitsEXT.html>"]
pub struct DebugReportFlagsEXT(pub(crate) Flags); pub struct DebugReportFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b1_1111, Flags); vk_bitflags_wrapped!(DebugReportFlagsEXT, Flags);
impl DebugReportFlagsEXT { impl DebugReportFlagsEXT {
pub const INFORMATION: Self = Self(0b1); pub const INFORMATION: Self = Self(0b1);
pub const WARNING: Self = Self(0b10); pub const WARNING: Self = Self(0b10);
@ -593,7 +589,7 @@ impl DebugReportFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryHandleTypeFlagBitsNV.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryHandleTypeFlagBitsNV.html>"]
pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags); pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags); vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, Flags);
impl ExternalMemoryHandleTypeFlagsNV { impl ExternalMemoryHandleTypeFlagsNV {
pub const OPAQUE_WIN32: Self = Self(0b1); pub const OPAQUE_WIN32: Self = Self(0b1);
pub const OPAQUE_WIN32_KMT: Self = Self(0b10); pub const OPAQUE_WIN32_KMT: Self = Self(0b10);
@ -604,7 +600,7 @@ impl ExternalMemoryHandleTypeFlagsNV {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryFeatureFlagBitsNV.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryFeatureFlagBitsNV.html>"]
pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags); pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags); vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, Flags);
impl ExternalMemoryFeatureFlagsNV { impl ExternalMemoryFeatureFlagsNV {
pub const DEDICATED_ONLY: Self = Self(0b1); pub const DEDICATED_ONLY: Self = Self(0b1);
pub const EXPORTABLE: Self = Self(0b10); pub const EXPORTABLE: Self = Self(0b10);
@ -614,7 +610,7 @@ impl ExternalMemoryFeatureFlagsNV {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubgroupFeatureFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubgroupFeatureFlagBits.html>"]
pub struct SubgroupFeatureFlags(pub(crate) Flags); pub struct SubgroupFeatureFlags(pub(crate) Flags);
vk_bitflags_wrapped!(SubgroupFeatureFlags, 0b1111_1111, Flags); vk_bitflags_wrapped!(SubgroupFeatureFlags, Flags);
impl SubgroupFeatureFlags { impl SubgroupFeatureFlags {
#[doc = "Basic subgroup operations"] #[doc = "Basic subgroup operations"]
pub const BASIC: Self = Self(0b1); pub const BASIC: Self = Self(0b1);
@ -637,7 +633,7 @@ impl SubgroupFeatureFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutUsageFlagBitsNV.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutUsageFlagBitsNV.html>"]
pub struct IndirectCommandsLayoutUsageFlagsNV(pub(crate) Flags); pub struct IndirectCommandsLayoutUsageFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNV, 0b111, Flags); vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNV, Flags);
impl IndirectCommandsLayoutUsageFlagsNV { impl IndirectCommandsLayoutUsageFlagsNV {
pub const EXPLICIT_PREPROCESS: Self = Self(0b1); pub const EXPLICIT_PREPROCESS: Self = Self(0b1);
pub const INDEXED_SEQUENCES: Self = Self(0b10); pub const INDEXED_SEQUENCES: Self = Self(0b10);
@ -647,7 +643,7 @@ impl IndirectCommandsLayoutUsageFlagsNV {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectStateFlagBitsNV.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectStateFlagBitsNV.html>"]
pub struct IndirectStateFlagsNV(pub(crate) Flags); pub struct IndirectStateFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(IndirectStateFlagsNV, 0b1, Flags); vk_bitflags_wrapped!(IndirectStateFlagsNV, Flags);
impl IndirectStateFlagsNV { impl IndirectStateFlagsNV {
pub const FLAG_FRONTFACE: Self = Self(0b1); pub const FLAG_FRONTFACE: Self = Self(0b1);
} }
@ -655,19 +651,19 @@ impl IndirectStateFlagsNV {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPrivateDataSlotCreateFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPrivateDataSlotCreateFlagBitsEXT.html>"]
pub struct PrivateDataSlotCreateFlagsEXT(pub(crate) Flags); pub struct PrivateDataSlotCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(PrivateDataSlotCreateFlagsEXT, 0b0, Flags); vk_bitflags_wrapped!(PrivateDataSlotCreateFlagsEXT, Flags);
impl PrivateDataSlotCreateFlagsEXT {} impl PrivateDataSlotCreateFlagsEXT {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutCreateFlagBits.html>"]
pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags); pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, Flags);
impl DescriptorSetLayoutCreateFlags {} impl DescriptorSetLayoutCreateFlags {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryHandleTypeFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryHandleTypeFlagBits.html>"]
pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags); pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags);
vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b111_1111, Flags); vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, Flags);
impl ExternalMemoryHandleTypeFlags { impl ExternalMemoryHandleTypeFlags {
pub const OPAQUE_FD: Self = Self(0b1); pub const OPAQUE_FD: Self = Self(0b1);
pub const OPAQUE_WIN32: Self = Self(0b10); pub const OPAQUE_WIN32: Self = Self(0b10);
@ -681,7 +677,7 @@ impl ExternalMemoryHandleTypeFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryFeatureFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryFeatureFlagBits.html>"]
pub struct ExternalMemoryFeatureFlags(pub(crate) Flags); pub struct ExternalMemoryFeatureFlags(pub(crate) Flags);
vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags); vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, Flags);
impl ExternalMemoryFeatureFlags { impl ExternalMemoryFeatureFlags {
pub const DEDICATED_ONLY: Self = Self(0b1); pub const DEDICATED_ONLY: Self = Self(0b1);
pub const EXPORTABLE: Self = Self(0b10); pub const EXPORTABLE: Self = Self(0b10);
@ -691,7 +687,7 @@ impl ExternalMemoryFeatureFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreHandleTypeFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreHandleTypeFlagBits.html>"]
pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags); pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags);
vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b1_1111, Flags); vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, Flags);
impl ExternalSemaphoreHandleTypeFlags { impl ExternalSemaphoreHandleTypeFlags {
pub const OPAQUE_FD: Self = Self(0b1); pub const OPAQUE_FD: Self = Self(0b1);
pub const OPAQUE_WIN32: Self = Self(0b10); pub const OPAQUE_WIN32: Self = Self(0b10);
@ -704,7 +700,7 @@ impl ExternalSemaphoreHandleTypeFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreFeatureFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreFeatureFlagBits.html>"]
pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags); pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags);
vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags); vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, Flags);
impl ExternalSemaphoreFeatureFlags { impl ExternalSemaphoreFeatureFlags {
pub const EXPORTABLE: Self = Self(0b1); pub const EXPORTABLE: Self = Self(0b1);
pub const IMPORTABLE: Self = Self(0b10); pub const IMPORTABLE: Self = Self(0b10);
@ -713,7 +709,7 @@ impl ExternalSemaphoreFeatureFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreImportFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreImportFlagBits.html>"]
pub struct SemaphoreImportFlags(pub(crate) Flags); pub struct SemaphoreImportFlags(pub(crate) Flags);
vk_bitflags_wrapped!(SemaphoreImportFlags, 0b1, Flags); vk_bitflags_wrapped!(SemaphoreImportFlags, Flags);
impl SemaphoreImportFlags { impl SemaphoreImportFlags {
pub const TEMPORARY: Self = Self(0b1); pub const TEMPORARY: Self = Self(0b1);
} }
@ -721,7 +717,7 @@ impl SemaphoreImportFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceHandleTypeFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceHandleTypeFlagBits.html>"]
pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags); pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags);
vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags); vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, Flags);
impl ExternalFenceHandleTypeFlags { impl ExternalFenceHandleTypeFlags {
pub const OPAQUE_FD: Self = Self(0b1); pub const OPAQUE_FD: Self = Self(0b1);
pub const OPAQUE_WIN32: Self = Self(0b10); pub const OPAQUE_WIN32: Self = Self(0b10);
@ -732,7 +728,7 @@ impl ExternalFenceHandleTypeFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceFeatureFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceFeatureFlagBits.html>"]
pub struct ExternalFenceFeatureFlags(pub(crate) Flags); pub struct ExternalFenceFeatureFlags(pub(crate) Flags);
vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags); vk_bitflags_wrapped!(ExternalFenceFeatureFlags, Flags);
impl ExternalFenceFeatureFlags { impl ExternalFenceFeatureFlags {
pub const EXPORTABLE: Self = Self(0b1); pub const EXPORTABLE: Self = Self(0b1);
pub const IMPORTABLE: Self = Self(0b10); pub const IMPORTABLE: Self = Self(0b10);
@ -741,7 +737,7 @@ impl ExternalFenceFeatureFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceImportFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceImportFlagBits.html>"]
pub struct FenceImportFlags(pub(crate) Flags); pub struct FenceImportFlags(pub(crate) Flags);
vk_bitflags_wrapped!(FenceImportFlags, 0b1, Flags); vk_bitflags_wrapped!(FenceImportFlags, Flags);
impl FenceImportFlags { impl FenceImportFlags {
pub const TEMPORARY: Self = Self(0b1); pub const TEMPORARY: Self = Self(0b1);
} }
@ -749,7 +745,7 @@ impl FenceImportFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCounterFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCounterFlagBitsEXT.html>"]
pub struct SurfaceCounterFlagsEXT(pub(crate) Flags); pub struct SurfaceCounterFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags); vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, Flags);
impl SurfaceCounterFlagsEXT { impl SurfaceCounterFlagsEXT {
pub const VBLANK: Self = Self(0b1); pub const VBLANK: Self = Self(0b1);
} }
@ -757,7 +753,7 @@ impl SurfaceCounterFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPeerMemoryFeatureFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPeerMemoryFeatureFlagBits.html>"]
pub struct PeerMemoryFeatureFlags(pub(crate) Flags); pub struct PeerMemoryFeatureFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PeerMemoryFeatureFlags, 0b1111, Flags); vk_bitflags_wrapped!(PeerMemoryFeatureFlags, Flags);
impl PeerMemoryFeatureFlags { impl PeerMemoryFeatureFlags {
#[doc = "Can read with vkCmdCopy commands"] #[doc = "Can read with vkCmdCopy commands"]
pub const COPY_SRC: Self = Self(0b1); pub const COPY_SRC: Self = Self(0b1);
@ -772,7 +768,7 @@ impl PeerMemoryFeatureFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryAllocateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryAllocateFlagBits.html>"]
pub struct MemoryAllocateFlags(pub(crate) Flags); pub struct MemoryAllocateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(MemoryAllocateFlags, 0b1, Flags); vk_bitflags_wrapped!(MemoryAllocateFlags, Flags);
impl MemoryAllocateFlags { impl MemoryAllocateFlags {
#[doc = "Force allocation on specific devices"] #[doc = "Force allocation on specific devices"]
pub const DEVICE_MASK: Self = Self(0b1); pub const DEVICE_MASK: Self = Self(0b1);
@ -781,7 +777,7 @@ impl MemoryAllocateFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupPresentModeFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupPresentModeFlagBitsKHR.html>"]
pub struct DeviceGroupPresentModeFlagsKHR(pub(crate) Flags); pub struct DeviceGroupPresentModeFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags); vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, Flags);
impl DeviceGroupPresentModeFlagsKHR { impl DeviceGroupPresentModeFlagsKHR {
#[doc = "Present from local memory"] #[doc = "Present from local memory"]
pub const LOCAL: Self = Self(0b1); pub const LOCAL: Self = Self(0b1);
@ -796,19 +792,19 @@ impl DeviceGroupPresentModeFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainCreateFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainCreateFlagBitsKHR.html>"]
pub struct SwapchainCreateFlagsKHR(pub(crate) Flags); pub struct SwapchainCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags); vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, Flags);
impl SwapchainCreateFlagsKHR {} impl SwapchainCreateFlagsKHR {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescriptionFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescriptionFlagBits.html>"]
pub struct SubpassDescriptionFlags(pub(crate) Flags); pub struct SubpassDescriptionFlags(pub(crate) Flags);
vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags); vk_bitflags_wrapped!(SubpassDescriptionFlags, Flags);
impl SubpassDescriptionFlags {} impl SubpassDescriptionFlags {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessageSeverityFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessageSeverityFlagBitsEXT.html>"]
pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags); pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, 0b1_0001_0001_0001, Flags); vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, Flags);
impl DebugUtilsMessageSeverityFlagsEXT { impl DebugUtilsMessageSeverityFlagsEXT {
pub const VERBOSE: Self = Self(0b1); pub const VERBOSE: Self = Self(0b1);
pub const INFO: Self = Self(0b1_0000); pub const INFO: Self = Self(0b1_0000);
@ -819,7 +815,7 @@ impl DebugUtilsMessageSeverityFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessageTypeFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessageTypeFlagBitsEXT.html>"]
pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags); pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, 0b111, Flags); vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, Flags);
impl DebugUtilsMessageTypeFlagsEXT { impl DebugUtilsMessageTypeFlagsEXT {
pub const GENERAL: Self = Self(0b1); pub const GENERAL: Self = Self(0b1);
pub const VALIDATION: Self = Self(0b10); pub const VALIDATION: Self = Self(0b10);
@ -829,7 +825,7 @@ impl DebugUtilsMessageTypeFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorBindingFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorBindingFlagBits.html>"]
pub struct DescriptorBindingFlags(pub(crate) Flags); pub struct DescriptorBindingFlags(pub(crate) Flags);
vk_bitflags_wrapped!(DescriptorBindingFlags, 0b1111, Flags); vk_bitflags_wrapped!(DescriptorBindingFlags, Flags);
impl DescriptorBindingFlags { impl DescriptorBindingFlags {
pub const UPDATE_AFTER_BIND: Self = Self(0b1); pub const UPDATE_AFTER_BIND: Self = Self(0b1);
pub const UPDATE_UNUSED_WHILE_PENDING: Self = Self(0b10); pub const UPDATE_UNUSED_WHILE_PENDING: Self = Self(0b10);
@ -840,7 +836,7 @@ impl DescriptorBindingFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkConditionalRenderingFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkConditionalRenderingFlagBitsEXT.html>"]
pub struct ConditionalRenderingFlagsEXT(pub(crate) Flags); pub struct ConditionalRenderingFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(ConditionalRenderingFlagsEXT, 0b1, Flags); vk_bitflags_wrapped!(ConditionalRenderingFlagsEXT, Flags);
impl ConditionalRenderingFlagsEXT { impl ConditionalRenderingFlagsEXT {
pub const INVERTED: Self = Self(0b1); pub const INVERTED: Self = Self(0b1);
} }
@ -848,7 +844,7 @@ impl ConditionalRenderingFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkResolveModeFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkResolveModeFlagBits.html>"]
pub struct ResolveModeFlags(pub(crate) Flags); pub struct ResolveModeFlags(pub(crate) Flags);
vk_bitflags_wrapped!(ResolveModeFlags, 0b1111, Flags); vk_bitflags_wrapped!(ResolveModeFlags, Flags);
impl ResolveModeFlags { impl ResolveModeFlags {
pub const NONE: Self = Self(0); pub const NONE: Self = Self(0);
pub const SAMPLE_ZERO: Self = Self(0b1); pub const SAMPLE_ZERO: Self = Self(0b1);
@ -860,7 +856,7 @@ impl ResolveModeFlags {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryInstanceFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryInstanceFlagBitsKHR.html>"]
pub struct GeometryInstanceFlagsKHR(pub(crate) Flags); pub struct GeometryInstanceFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(GeometryInstanceFlagsKHR, 0b1111, Flags); vk_bitflags_wrapped!(GeometryInstanceFlagsKHR, Flags);
impl GeometryInstanceFlagsKHR { impl GeometryInstanceFlagsKHR {
pub const TRIANGLE_FACING_CULL_DISABLE: Self = Self(0b1); pub const TRIANGLE_FACING_CULL_DISABLE: Self = Self(0b1);
pub const TRIANGLE_FLIP_FACING: Self = Self(0b10); pub const TRIANGLE_FLIP_FACING: Self = Self(0b10);
@ -872,7 +868,7 @@ impl GeometryInstanceFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryFlagBitsKHR.html>"]
pub struct GeometryFlagsKHR(pub(crate) Flags); pub struct GeometryFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(GeometryFlagsKHR, 0b11, Flags); vk_bitflags_wrapped!(GeometryFlagsKHR, Flags);
impl GeometryFlagsKHR { impl GeometryFlagsKHR {
pub const OPAQUE: Self = Self(0b1); pub const OPAQUE: Self = Self(0b1);
pub const NO_DUPLICATE_ANY_HIT_INVOCATION: Self = Self(0b10); pub const NO_DUPLICATE_ANY_HIT_INVOCATION: Self = Self(0b10);
@ -881,7 +877,7 @@ impl GeometryFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBuildAccelerationStructureFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBuildAccelerationStructureFlagBitsKHR.html>"]
pub struct BuildAccelerationStructureFlagsKHR(pub(crate) Flags); pub struct BuildAccelerationStructureFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(BuildAccelerationStructureFlagsKHR, 0b1_1111, Flags); vk_bitflags_wrapped!(BuildAccelerationStructureFlagsKHR, Flags);
impl BuildAccelerationStructureFlagsKHR { impl BuildAccelerationStructureFlagsKHR {
pub const ALLOW_UPDATE: Self = Self(0b1); pub const ALLOW_UPDATE: Self = Self(0b1);
pub const ALLOW_COMPACTION: Self = Self(0b10); pub const ALLOW_COMPACTION: Self = Self(0b10);
@ -893,7 +889,7 @@ impl BuildAccelerationStructureFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureCreateFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureCreateFlagBitsKHR.html>"]
pub struct AccelerationStructureCreateFlagsKHR(pub(crate) Flags); pub struct AccelerationStructureCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(AccelerationStructureCreateFlagsKHR, 0b1, Flags); vk_bitflags_wrapped!(AccelerationStructureCreateFlagsKHR, Flags);
impl AccelerationStructureCreateFlagsKHR { impl AccelerationStructureCreateFlagsKHR {
pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1); pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1);
} }
@ -901,13 +897,13 @@ impl AccelerationStructureCreateFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferCreateFlagBits.html>"]
pub struct FramebufferCreateFlags(pub(crate) Flags); pub struct FramebufferCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(FramebufferCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(FramebufferCreateFlags, Flags);
impl FramebufferCreateFlags {} impl FramebufferCreateFlags {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceDiagnosticsConfigFlagBitsNV.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceDiagnosticsConfigFlagBitsNV.html>"]
pub struct DeviceDiagnosticsConfigFlagsNV(pub(crate) Flags); pub struct DeviceDiagnosticsConfigFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(DeviceDiagnosticsConfigFlagsNV, 0b111, Flags); vk_bitflags_wrapped!(DeviceDiagnosticsConfigFlagsNV, Flags);
impl DeviceDiagnosticsConfigFlagsNV { impl DeviceDiagnosticsConfigFlagsNV {
pub const ENABLE_SHADER_DEBUG_INFO: Self = Self(0b1); pub const ENABLE_SHADER_DEBUG_INFO: Self = Self(0b1);
pub const ENABLE_RESOURCE_TRACKING: Self = Self(0b10); pub const ENABLE_RESOURCE_TRACKING: Self = Self(0b10);
@ -917,7 +913,7 @@ impl DeviceDiagnosticsConfigFlagsNV {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreationFeedbackFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreationFeedbackFlagBitsEXT.html>"]
pub struct PipelineCreationFeedbackFlagsEXT(pub(crate) Flags); pub struct PipelineCreationFeedbackFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineCreationFeedbackFlagsEXT, 0b111, Flags); vk_bitflags_wrapped!(PipelineCreationFeedbackFlagsEXT, Flags);
impl PipelineCreationFeedbackFlagsEXT { impl PipelineCreationFeedbackFlagsEXT {
pub const VALID: Self = Self(0b1); pub const VALID: Self = Self(0b1);
pub const APPLICATION_PIPELINE_CACHE_HIT: Self = Self(0b10); pub const APPLICATION_PIPELINE_CACHE_HIT: Self = Self(0b10);
@ -927,7 +923,7 @@ impl PipelineCreationFeedbackFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterDescriptionFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterDescriptionFlagBitsKHR.html>"]
pub struct PerformanceCounterDescriptionFlagsKHR(pub(crate) Flags); pub struct PerformanceCounterDescriptionFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(PerformanceCounterDescriptionFlagsKHR, 0b11, Flags); vk_bitflags_wrapped!(PerformanceCounterDescriptionFlagsKHR, Flags);
impl PerformanceCounterDescriptionFlagsKHR { impl PerformanceCounterDescriptionFlagsKHR {
pub const PERFORMANCE_IMPACTING: Self = Self(0b1); pub const PERFORMANCE_IMPACTING: Self = Self(0b1);
pub const CONCURRENTLY_IMPACTED: Self = Self(0b10); pub const CONCURRENTLY_IMPACTED: Self = Self(0b10);
@ -936,31 +932,31 @@ impl PerformanceCounterDescriptionFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAcquireProfilingLockFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAcquireProfilingLockFlagBitsKHR.html>"]
pub struct AcquireProfilingLockFlagsKHR(pub(crate) Flags); pub struct AcquireProfilingLockFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(AcquireProfilingLockFlagsKHR, 0b0, Flags); vk_bitflags_wrapped!(AcquireProfilingLockFlagsKHR, Flags);
impl AcquireProfilingLockFlagsKHR {} impl AcquireProfilingLockFlagsKHR {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderCorePropertiesFlagBitsAMD.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderCorePropertiesFlagBitsAMD.html>"]
pub struct ShaderCorePropertiesFlagsAMD(pub(crate) Flags); pub struct ShaderCorePropertiesFlagsAMD(pub(crate) Flags);
vk_bitflags_wrapped!(ShaderCorePropertiesFlagsAMD, 0b0, Flags); vk_bitflags_wrapped!(ShaderCorePropertiesFlagsAMD, Flags);
impl ShaderCorePropertiesFlagsAMD {} impl ShaderCorePropertiesFlagsAMD {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModuleCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModuleCreateFlagBits.html>"]
pub struct ShaderModuleCreateFlags(pub(crate) Flags); pub struct ShaderModuleCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(ShaderModuleCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(ShaderModuleCreateFlags, Flags);
impl ShaderModuleCreateFlags {} impl ShaderModuleCreateFlags {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCompilerControlFlagBitsAMD.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCompilerControlFlagBitsAMD.html>"]
pub struct PipelineCompilerControlFlagsAMD(pub(crate) Flags); pub struct PipelineCompilerControlFlagsAMD(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineCompilerControlFlagsAMD, 0b0, Flags); vk_bitflags_wrapped!(PipelineCompilerControlFlagsAMD, Flags);
impl PipelineCompilerControlFlagsAMD {} impl PipelineCompilerControlFlagsAMD {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkToolPurposeFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkToolPurposeFlagBitsEXT.html>"]
pub struct ToolPurposeFlagsEXT(pub(crate) Flags); pub struct ToolPurposeFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(ToolPurposeFlagsEXT, 0b1_1111, Flags); vk_bitflags_wrapped!(ToolPurposeFlagsEXT, Flags);
impl ToolPurposeFlagsEXT { impl ToolPurposeFlagsEXT {
pub const VALIDATION: Self = Self(0b1); pub const VALIDATION: Self = Self(0b1);
pub const PROFILING: Self = Self(0b10); pub const PROFILING: Self = Self(0b10);
@ -972,11 +968,7 @@ impl ToolPurposeFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccessFlagBits2KHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccessFlagBits2KHR.html>"]
pub struct AccessFlags2KHR(pub(crate) Flags64); pub struct AccessFlags2KHR(pub(crate) Flags64);
vk_bitflags_wrapped!( vk_bitflags_wrapped!(AccessFlags2KHR, Flags64);
AccessFlags2KHR,
0b111_0000_0000_0000_0001_1111_1111_1111_1111,
Flags64
);
impl AccessFlags2KHR { impl AccessFlags2KHR {
pub const NONE: Self = Self(0); pub const NONE: Self = Self(0);
pub const INDIRECT_COMMAND_READ: Self = Self(0b1); pub const INDIRECT_COMMAND_READ: Self = Self(0b1);
@ -1004,11 +996,7 @@ impl AccessFlags2KHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineStageFlagBits2KHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineStageFlagBits2KHR.html>"]
pub struct PipelineStageFlags2KHR(pub(crate) Flags64); pub struct PipelineStageFlags2KHR(pub(crate) Flags64);
vk_bitflags_wrapped!( vk_bitflags_wrapped!(PipelineStageFlags2KHR, Flags64);
PipelineStageFlags2KHR,
0b111_1111_0000_0000_0000_0001_1111_1111_1111_1111,
Flags64
);
impl PipelineStageFlags2KHR { impl PipelineStageFlags2KHR {
pub const NONE: Self = Self(0); pub const NONE: Self = Self(0);
pub const TOP_OF_PIPE: Self = Self(0b1); pub const TOP_OF_PIPE: Self = Self(0b1);
@ -1043,7 +1031,7 @@ impl PipelineStageFlags2KHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubmitFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubmitFlagBitsKHR.html>"]
pub struct SubmitFlagsKHR(pub(crate) Flags); pub struct SubmitFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(SubmitFlagsKHR, 0b1, Flags); vk_bitflags_wrapped!(SubmitFlagsKHR, Flags);
impl SubmitFlagsKHR { impl SubmitFlagsKHR {
pub const PROTECTED: Self = Self(0b1); pub const PROTECTED: Self = Self(0b1);
} }
@ -1051,19 +1039,19 @@ impl SubmitFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkEventCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkEventCreateFlagBits.html>"]
pub struct EventCreateFlags(pub(crate) Flags); pub struct EventCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(EventCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(EventCreateFlags, Flags);
impl EventCreateFlags {} impl EventCreateFlags {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLayoutCreateFlagBits.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLayoutCreateFlagBits.html>"]
pub struct PipelineLayoutCreateFlags(pub(crate) Flags); pub struct PipelineLayoutCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineLayoutCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(PipelineLayoutCreateFlags, Flags);
impl PipelineLayoutCreateFlags {} impl PipelineLayoutCreateFlags {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodecOperationFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodecOperationFlagBitsKHR.html>"]
pub struct VideoCodecOperationFlagsKHR(pub(crate) Flags); pub struct VideoCodecOperationFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, 0b0, Flags); vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, Flags);
impl VideoCodecOperationFlagsKHR { impl VideoCodecOperationFlagsKHR {
pub const INVALID: Self = Self(0); pub const INVALID: Self = Self(0);
} }
@ -1071,7 +1059,7 @@ impl VideoCodecOperationFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoChromaSubsamplingFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoChromaSubsamplingFlagBitsKHR.html>"]
pub struct VideoChromaSubsamplingFlagsKHR(pub(crate) Flags); pub struct VideoChromaSubsamplingFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(VideoChromaSubsamplingFlagsKHR, 0b1111, Flags); vk_bitflags_wrapped!(VideoChromaSubsamplingFlagsKHR, Flags);
impl VideoChromaSubsamplingFlagsKHR { impl VideoChromaSubsamplingFlagsKHR {
pub const INVALID: Self = Self(0); pub const INVALID: Self = Self(0);
pub const MONOCHROME: Self = Self(0b1); pub const MONOCHROME: Self = Self(0b1);
@ -1083,7 +1071,7 @@ impl VideoChromaSubsamplingFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoComponentBitDepthFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoComponentBitDepthFlagBitsKHR.html>"]
pub struct VideoComponentBitDepthFlagsKHR(pub(crate) Flags); pub struct VideoComponentBitDepthFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(VideoComponentBitDepthFlagsKHR, 0b1_0101, Flags); vk_bitflags_wrapped!(VideoComponentBitDepthFlagsKHR, Flags);
impl VideoComponentBitDepthFlagsKHR { impl VideoComponentBitDepthFlagsKHR {
pub const INVALID: Self = Self(0); pub const INVALID: Self = Self(0);
pub const TYPE_8: Self = Self(0b1); pub const TYPE_8: Self = Self(0b1);
@ -1094,7 +1082,7 @@ impl VideoComponentBitDepthFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCapabilityFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCapabilityFlagBitsKHR.html>"]
pub struct VideoCapabilityFlagsKHR(pub(crate) Flags); pub struct VideoCapabilityFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(VideoCapabilityFlagsKHR, 0b11, Flags); vk_bitflags_wrapped!(VideoCapabilityFlagsKHR, Flags);
impl VideoCapabilityFlagsKHR { impl VideoCapabilityFlagsKHR {
pub const PROTECTED_CONTENT: Self = Self(0b1); pub const PROTECTED_CONTENT: Self = Self(0b1);
pub const SEPARATE_REFERENCE_IMAGES: Self = Self(0b10); pub const SEPARATE_REFERENCE_IMAGES: Self = Self(0b10);
@ -1103,7 +1091,7 @@ impl VideoCapabilityFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoSessionCreateFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoSessionCreateFlagBitsKHR.html>"]
pub struct VideoSessionCreateFlagsKHR(pub(crate) Flags); pub struct VideoSessionCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(VideoSessionCreateFlagsKHR, 0b1, Flags); vk_bitflags_wrapped!(VideoSessionCreateFlagsKHR, Flags);
impl VideoSessionCreateFlagsKHR { impl VideoSessionCreateFlagsKHR {
pub const DEFAULT: Self = Self(0); pub const DEFAULT: Self = Self(0);
pub const PROTECTED_CONTENT: Self = Self(0b1); pub const PROTECTED_CONTENT: Self = Self(0b1);
@ -1112,7 +1100,7 @@ impl VideoSessionCreateFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodingQualityPresetFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodingQualityPresetFlagBitsKHR.html>"]
pub struct VideoCodingQualityPresetFlagsKHR(pub(crate) Flags); pub struct VideoCodingQualityPresetFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(VideoCodingQualityPresetFlagsKHR, 0b111, Flags); vk_bitflags_wrapped!(VideoCodingQualityPresetFlagsKHR, Flags);
impl VideoCodingQualityPresetFlagsKHR { impl VideoCodingQualityPresetFlagsKHR {
pub const NORMAL: Self = Self(0b1); pub const NORMAL: Self = Self(0b1);
pub const POWER: Self = Self(0b10); pub const POWER: Self = Self(0b10);
@ -1122,7 +1110,7 @@ impl VideoCodingQualityPresetFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264PictureLayoutFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264PictureLayoutFlagBitsEXT.html>"]
pub struct VideoDecodeH264PictureLayoutFlagsEXT(pub(crate) Flags); pub struct VideoDecodeH264PictureLayoutFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoDecodeH264PictureLayoutFlagsEXT, 0b11, Flags); vk_bitflags_wrapped!(VideoDecodeH264PictureLayoutFlagsEXT, Flags);
impl VideoDecodeH264PictureLayoutFlagsEXT { impl VideoDecodeH264PictureLayoutFlagsEXT {
pub const PROGRESSIVE: Self = Self(0); pub const PROGRESSIVE: Self = Self(0);
pub const INTERLACED_INTERLEAVED_LINES: Self = Self(0b1); pub const INTERLACED_INTERLEAVED_LINES: Self = Self(0b1);
@ -1132,7 +1120,7 @@ impl VideoDecodeH264PictureLayoutFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodingControlFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodingControlFlagBitsKHR.html>"]
pub struct VideoCodingControlFlagsKHR(pub(crate) Flags); pub struct VideoCodingControlFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(VideoCodingControlFlagsKHR, 0b1, Flags); vk_bitflags_wrapped!(VideoCodingControlFlagsKHR, Flags);
impl VideoCodingControlFlagsKHR { impl VideoCodingControlFlagsKHR {
pub const DEFAULT: Self = Self(0); pub const DEFAULT: Self = Self(0);
pub const RESET: Self = Self(0b1); pub const RESET: Self = Self(0b1);
@ -1141,7 +1129,7 @@ impl VideoCodingControlFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeFlagBitsKHR.html>"]
pub struct VideoDecodeFlagsKHR(pub(crate) Flags); pub struct VideoDecodeFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(VideoDecodeFlagsKHR, 0b1, Flags); vk_bitflags_wrapped!(VideoDecodeFlagsKHR, Flags);
impl VideoDecodeFlagsKHR { impl VideoDecodeFlagsKHR {
pub const DEFAULT: Self = Self(0); pub const DEFAULT: Self = Self(0);
pub const RESERVED_0: Self = Self(0b1); pub const RESERVED_0: Self = Self(0b1);
@ -1150,7 +1138,7 @@ impl VideoDecodeFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeFlagBitsKHR.html>"]
pub struct VideoEncodeFlagsKHR(pub(crate) Flags); pub struct VideoEncodeFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeFlagsKHR, 0b1, Flags); vk_bitflags_wrapped!(VideoEncodeFlagsKHR, Flags);
impl VideoEncodeFlagsKHR { impl VideoEncodeFlagsKHR {
pub const DEFAULT: Self = Self(0); pub const DEFAULT: Self = Self(0);
pub const RESERVED_0: Self = Self(0b1); pub const RESERVED_0: Self = Self(0b1);
@ -1159,7 +1147,7 @@ impl VideoEncodeFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeRateControlFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeRateControlFlagBitsKHR.html>"]
pub struct VideoEncodeRateControlFlagsKHR(pub(crate) Flags); pub struct VideoEncodeRateControlFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeRateControlFlagsKHR, 0b1, Flags); vk_bitflags_wrapped!(VideoEncodeRateControlFlagsKHR, Flags);
impl VideoEncodeRateControlFlagsKHR { impl VideoEncodeRateControlFlagsKHR {
pub const DEFAULT: Self = Self(0); pub const DEFAULT: Self = Self(0);
pub const RESET: Self = Self(0b1); pub const RESET: Self = Self(0b1);
@ -1168,7 +1156,7 @@ impl VideoEncodeRateControlFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeRateControlModeFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeRateControlModeFlagBitsKHR.html>"]
pub struct VideoEncodeRateControlModeFlagsKHR(pub(crate) Flags); pub struct VideoEncodeRateControlModeFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeRateControlModeFlagsKHR, 0b11, Flags); vk_bitflags_wrapped!(VideoEncodeRateControlModeFlagsKHR, Flags);
impl VideoEncodeRateControlModeFlagsKHR { impl VideoEncodeRateControlModeFlagsKHR {
pub const NONE: Self = Self(0); pub const NONE: Self = Self(0);
pub const CBR: Self = Self(1); pub const CBR: Self = Self(1);
@ -1178,7 +1166,7 @@ impl VideoEncodeRateControlModeFlagsKHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264CapabilityFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264CapabilityFlagBitsEXT.html>"]
pub struct VideoEncodeH264CapabilityFlagsEXT(pub(crate) Flags); pub struct VideoEncodeH264CapabilityFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH264CapabilityFlagsEXT, 0b111_1111_1111, Flags); vk_bitflags_wrapped!(VideoEncodeH264CapabilityFlagsEXT, Flags);
impl VideoEncodeH264CapabilityFlagsEXT { impl VideoEncodeH264CapabilityFlagsEXT {
pub const CABAC: Self = Self(0b1); pub const CABAC: Self = Self(0b1);
pub const CAVLC: Self = Self(0b10); pub const CAVLC: Self = Self(0b10);
@ -1196,7 +1184,7 @@ impl VideoEncodeH264CapabilityFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264InputModeFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264InputModeFlagBitsEXT.html>"]
pub struct VideoEncodeH264InputModeFlagsEXT(pub(crate) Flags); pub struct VideoEncodeH264InputModeFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH264InputModeFlagsEXT, 0b111, Flags); vk_bitflags_wrapped!(VideoEncodeH264InputModeFlagsEXT, Flags);
impl VideoEncodeH264InputModeFlagsEXT { impl VideoEncodeH264InputModeFlagsEXT {
pub const FRAME: Self = Self(0b1); pub const FRAME: Self = Self(0b1);
pub const SLICE: Self = Self(0b10); pub const SLICE: Self = Self(0b10);
@ -1206,7 +1194,7 @@ impl VideoEncodeH264InputModeFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264OutputModeFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264OutputModeFlagBitsEXT.html>"]
pub struct VideoEncodeH264OutputModeFlagsEXT(pub(crate) Flags); pub struct VideoEncodeH264OutputModeFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH264OutputModeFlagsEXT, 0b111, Flags); vk_bitflags_wrapped!(VideoEncodeH264OutputModeFlagsEXT, Flags);
impl VideoEncodeH264OutputModeFlagsEXT { impl VideoEncodeH264OutputModeFlagsEXT {
pub const FRAME: Self = Self(0b1); pub const FRAME: Self = Self(0b1);
pub const SLICE: Self = Self(0b10); pub const SLICE: Self = Self(0b10);
@ -1216,7 +1204,7 @@ impl VideoEncodeH264OutputModeFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264CreateFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264CreateFlagBitsEXT.html>"]
pub struct VideoEncodeH264CreateFlagsEXT(pub(crate) Flags); pub struct VideoEncodeH264CreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH264CreateFlagsEXT, 0b1, Flags); vk_bitflags_wrapped!(VideoEncodeH264CreateFlagsEXT, Flags);
impl VideoEncodeH264CreateFlagsEXT { impl VideoEncodeH264CreateFlagsEXT {
pub const DEFAULT: Self = Self(0); pub const DEFAULT: Self = Self(0);
pub const RESERVED_0: Self = Self(0b1); pub const RESERVED_0: Self = Self(0b1);
@ -1225,13 +1213,13 @@ impl VideoEncodeH264CreateFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageFormatConstraintsFlagBitsFUCHSIA.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageFormatConstraintsFlagBitsFUCHSIA.html>"]
pub struct ImageFormatConstraintsFlagsFUCHSIA(pub(crate) Flags); pub struct ImageFormatConstraintsFlagsFUCHSIA(pub(crate) Flags);
vk_bitflags_wrapped!(ImageFormatConstraintsFlagsFUCHSIA, 0b0, Flags); vk_bitflags_wrapped!(ImageFormatConstraintsFlagsFUCHSIA, Flags);
impl ImageFormatConstraintsFlagsFUCHSIA {} impl ImageFormatConstraintsFlagsFUCHSIA {}
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageConstraintsInfoFlagBitsFUCHSIA.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageConstraintsInfoFlagBitsFUCHSIA.html>"]
pub struct ImageConstraintsInfoFlagsFUCHSIA(pub(crate) Flags); pub struct ImageConstraintsInfoFlagsFUCHSIA(pub(crate) Flags);
vk_bitflags_wrapped!(ImageConstraintsInfoFlagsFUCHSIA, 0b1_1111, Flags); vk_bitflags_wrapped!(ImageConstraintsInfoFlagsFUCHSIA, Flags);
impl ImageConstraintsInfoFlagsFUCHSIA { impl ImageConstraintsInfoFlagsFUCHSIA {
pub const CPU_READ_RARELY: Self = Self(0b1); pub const CPU_READ_RARELY: Self = Self(0b1);
pub const CPU_READ_OFTEN: Self = Self(0b10); pub const CPU_READ_OFTEN: Self = Self(0b10);
@ -1243,11 +1231,7 @@ impl ImageConstraintsInfoFlagsFUCHSIA {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatFeatureFlagBits2KHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatFeatureFlagBits2KHR.html>"]
pub struct FormatFeatureFlags2KHR(pub(crate) Flags64); pub struct FormatFeatureFlags2KHR(pub(crate) Flags64);
vk_bitflags_wrapped!( vk_bitflags_wrapped!(FormatFeatureFlags2KHR, Flags64);
FormatFeatureFlags2KHR,
0b11_1000_0000_1111_1111_1111_1111_1111_1111,
Flags64
);
impl FormatFeatureFlags2KHR { impl FormatFeatureFlags2KHR {
pub const SAMPLED_IMAGE: Self = Self(0b1); pub const SAMPLED_IMAGE: Self = Self(0b1);
pub const STORAGE_IMAGE: Self = Self(0b10); pub const STORAGE_IMAGE: Self = Self(0b10);
@ -1286,7 +1270,7 @@ impl FormatFeatureFlags2KHR {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265InputModeFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265InputModeFlagBitsEXT.html>"]
pub struct VideoEncodeH265InputModeFlagsEXT(pub(crate) Flags); pub struct VideoEncodeH265InputModeFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH265InputModeFlagsEXT, 0b111, Flags); vk_bitflags_wrapped!(VideoEncodeH265InputModeFlagsEXT, Flags);
impl VideoEncodeH265InputModeFlagsEXT { impl VideoEncodeH265InputModeFlagsEXT {
pub const FRAME: Self = Self(0b1); pub const FRAME: Self = Self(0b1);
pub const SLICE: Self = Self(0b10); pub const SLICE: Self = Self(0b10);
@ -1296,7 +1280,7 @@ impl VideoEncodeH265InputModeFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265OutputModeFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265OutputModeFlagBitsEXT.html>"]
pub struct VideoEncodeH265OutputModeFlagsEXT(pub(crate) Flags); pub struct VideoEncodeH265OutputModeFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH265OutputModeFlagsEXT, 0b111, Flags); vk_bitflags_wrapped!(VideoEncodeH265OutputModeFlagsEXT, Flags);
impl VideoEncodeH265OutputModeFlagsEXT { impl VideoEncodeH265OutputModeFlagsEXT {
pub const FRAME: Self = Self(0b1); pub const FRAME: Self = Self(0b1);
pub const SLICE: Self = Self(0b10); pub const SLICE: Self = Self(0b10);
@ -1306,7 +1290,7 @@ impl VideoEncodeH265OutputModeFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265CtbSizeFlagBitsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265CtbSizeFlagBitsEXT.html>"]
pub struct VideoEncodeH265CtbSizeFlagsEXT(pub(crate) Flags); pub struct VideoEncodeH265CtbSizeFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH265CtbSizeFlagsEXT, 0b1111, Flags); vk_bitflags_wrapped!(VideoEncodeH265CtbSizeFlagsEXT, Flags);
impl VideoEncodeH265CtbSizeFlagsEXT { impl VideoEncodeH265CtbSizeFlagsEXT {
pub const TYPE_8: Self = Self(0b1); pub const TYPE_8: Self = Self(0b1);
pub const TYPE_16: Self = Self(0b10); pub const TYPE_16: Self = Self(0b10);
@ -1317,7 +1301,7 @@ impl VideoEncodeH265CtbSizeFlagsEXT {
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderingFlagBitsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderingFlagBitsKHR.html>"]
pub struct RenderingFlagsKHR(pub(crate) Flags); pub struct RenderingFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(RenderingFlagsKHR, 0b111, Flags); vk_bitflags_wrapped!(RenderingFlagsKHR, Flags);
impl RenderingFlagsKHR { impl RenderingFlagsKHR {
pub const CONTENTS_SECONDARY_COMMAND_BUFFERS: Self = Self(0b1); pub const CONTENTS_SECONDARY_COMMAND_BUFFERS: Self = Self(0b1);
pub const SUSPENDING: Self = Self(0b10); pub const SUSPENDING: Self = Self(0b10);

114
ash/src/vk/definitions.rs
View file

@ -73,275 +73,267 @@ pub type DeviceAddress = u64;
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolCreateFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolCreateFlags.html>"]
pub struct QueryPoolCreateFlags(pub(crate) Flags); pub struct QueryPoolCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(QueryPoolCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(QueryPoolCreateFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDepthStencilStateCreateFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDepthStencilStateCreateFlags.html>"]
pub struct PipelineDepthStencilStateCreateFlags(pub(crate) Flags); pub struct PipelineDepthStencilStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDynamicStateCreateFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDynamicStateCreateFlags.html>"]
pub struct PipelineDynamicStateCreateFlags(pub(crate) Flags); pub struct PipelineDynamicStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendStateCreateFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendStateCreateFlags.html>"]
pub struct PipelineColorBlendStateCreateFlags(pub(crate) Flags); pub struct PipelineColorBlendStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineMultisampleStateCreateFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineMultisampleStateCreateFlags.html>"]
pub struct PipelineMultisampleStateCreateFlags(pub(crate) Flags); pub struct PipelineMultisampleStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateCreateFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateCreateFlags.html>"]
pub struct PipelineRasterizationStateCreateFlags(pub(crate) Flags); pub struct PipelineRasterizationStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportStateCreateFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportStateCreateFlags.html>"]
pub struct PipelineViewportStateCreateFlags(pub(crate) Flags); pub struct PipelineViewportStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineTessellationStateCreateFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineTessellationStateCreateFlags.html>"]
pub struct PipelineTessellationStateCreateFlags(pub(crate) Flags); pub struct PipelineTessellationStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineInputAssemblyStateCreateFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineInputAssemblyStateCreateFlags.html>"]
pub struct PipelineInputAssemblyStateCreateFlags(pub(crate) Flags); pub struct PipelineInputAssemblyStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineVertexInputStateCreateFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineVertexInputStateCreateFlags.html>"]
pub struct PipelineVertexInputStateCreateFlags(pub(crate) Flags); pub struct PipelineVertexInputStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferViewCreateFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferViewCreateFlags.html>"]
pub struct BufferViewCreateFlags(pub(crate) Flags); pub struct BufferViewCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(BufferViewCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(BufferViewCreateFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstanceCreateFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstanceCreateFlags.html>"]
pub struct InstanceCreateFlags(pub(crate) Flags); pub struct InstanceCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(InstanceCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(InstanceCreateFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceCreateFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceCreateFlags.html>"]
pub struct DeviceCreateFlags(pub(crate) Flags); pub struct DeviceCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(DeviceCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(DeviceCreateFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryMapFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryMapFlags.html>"]
pub struct MemoryMapFlags(pub(crate) Flags); pub struct MemoryMapFlags(pub(crate) Flags);
vk_bitflags_wrapped!(MemoryMapFlags, 0b0, Flags); vk_bitflags_wrapped!(MemoryMapFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolResetFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolResetFlags.html>"]
pub struct DescriptorPoolResetFlags(pub(crate) Flags); pub struct DescriptorPoolResetFlags(pub(crate) Flags);
vk_bitflags_wrapped!(DescriptorPoolResetFlags, 0b0, Flags); vk_bitflags_wrapped!(DescriptorPoolResetFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplateCreateFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplateCreateFlags.html>"]
pub struct DescriptorUpdateTemplateCreateFlags(pub(crate) Flags); pub struct DescriptorUpdateTemplateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, 0b0, Flags); vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMotionInfoFlagsNV.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMotionInfoFlagsNV.html>"]
pub struct AccelerationStructureMotionInfoFlagsNV(pub(crate) Flags); pub struct AccelerationStructureMotionInfoFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(AccelerationStructureMotionInfoFlagsNV, 0b0, Flags); vk_bitflags_wrapped!(AccelerationStructureMotionInfoFlagsNV, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMotionInstanceFlagsNV.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMotionInstanceFlagsNV.html>"]
pub struct AccelerationStructureMotionInstanceFlagsNV(pub(crate) Flags); pub struct AccelerationStructureMotionInstanceFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(AccelerationStructureMotionInstanceFlagsNV, 0b0, Flags); vk_bitflags_wrapped!(AccelerationStructureMotionInstanceFlagsNV, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeCreateFlagsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeCreateFlagsKHR.html>"]
pub struct DisplayModeCreateFlagsKHR(pub(crate) Flags); pub struct DisplayModeCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, 0b0, Flags); vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplaySurfaceCreateFlagsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplaySurfaceCreateFlagsKHR.html>"]
pub struct DisplaySurfaceCreateFlagsKHR(pub(crate) Flags); pub struct DisplaySurfaceCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, 0b0, Flags); vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidSurfaceCreateFlagsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidSurfaceCreateFlagsKHR.html>"]
pub struct AndroidSurfaceCreateFlagsKHR(pub(crate) Flags); pub struct AndroidSurfaceCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, 0b0, Flags); vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViSurfaceCreateFlagsNN.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViSurfaceCreateFlagsNN.html>"]
pub struct ViSurfaceCreateFlagsNN(pub(crate) Flags); pub struct ViSurfaceCreateFlagsNN(pub(crate) Flags);
vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, 0b0, Flags); vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWaylandSurfaceCreateFlagsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWaylandSurfaceCreateFlagsKHR.html>"]
pub struct WaylandSurfaceCreateFlagsKHR(pub(crate) Flags); pub struct WaylandSurfaceCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, 0b0, Flags); vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWin32SurfaceCreateFlagsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWin32SurfaceCreateFlagsKHR.html>"]
pub struct Win32SurfaceCreateFlagsKHR(pub(crate) Flags); pub struct Win32SurfaceCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, 0b0, Flags); vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXlibSurfaceCreateFlagsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXlibSurfaceCreateFlagsKHR.html>"]
pub struct XlibSurfaceCreateFlagsKHR(pub(crate) Flags); pub struct XlibSurfaceCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, 0b0, Flags); vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXcbSurfaceCreateFlagsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXcbSurfaceCreateFlagsKHR.html>"]
pub struct XcbSurfaceCreateFlagsKHR(pub(crate) Flags); pub struct XcbSurfaceCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, 0b0, Flags); vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDirectFBSurfaceCreateFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDirectFBSurfaceCreateFlagsEXT.html>"]
pub struct DirectFBSurfaceCreateFlagsEXT(pub(crate) Flags); pub struct DirectFBSurfaceCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(DirectFBSurfaceCreateFlagsEXT, 0b0, Flags); vk_bitflags_wrapped!(DirectFBSurfaceCreateFlagsEXT, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIOSSurfaceCreateFlagsMVK.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIOSSurfaceCreateFlagsMVK.html>"]
pub struct IOSSurfaceCreateFlagsMVK(pub(crate) Flags); pub struct IOSSurfaceCreateFlagsMVK(pub(crate) Flags);
vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, 0b0, Flags); vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMacOSSurfaceCreateFlagsMVK.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMacOSSurfaceCreateFlagsMVK.html>"]
pub struct MacOSSurfaceCreateFlagsMVK(pub(crate) Flags); pub struct MacOSSurfaceCreateFlagsMVK(pub(crate) Flags);
vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, 0b0, Flags); vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMetalSurfaceCreateFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMetalSurfaceCreateFlagsEXT.html>"]
pub struct MetalSurfaceCreateFlagsEXT(pub(crate) Flags); pub struct MetalSurfaceCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(MetalSurfaceCreateFlagsEXT, 0b0, Flags); vk_bitflags_wrapped!(MetalSurfaceCreateFlagsEXT, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImagePipeSurfaceCreateFlagsFUCHSIA.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImagePipeSurfaceCreateFlagsFUCHSIA.html>"]
pub struct ImagePipeSurfaceCreateFlagsFUCHSIA(pub(crate) Flags); pub struct ImagePipeSurfaceCreateFlagsFUCHSIA(pub(crate) Flags);
vk_bitflags_wrapped!(ImagePipeSurfaceCreateFlagsFUCHSIA, 0b0, Flags); vk_bitflags_wrapped!(ImagePipeSurfaceCreateFlagsFUCHSIA, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStreamDescriptorSurfaceCreateFlagsGGP.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStreamDescriptorSurfaceCreateFlagsGGP.html>"]
pub struct StreamDescriptorSurfaceCreateFlagsGGP(pub(crate) Flags); pub struct StreamDescriptorSurfaceCreateFlagsGGP(pub(crate) Flags);
vk_bitflags_wrapped!(StreamDescriptorSurfaceCreateFlagsGGP, 0b0, Flags); vk_bitflags_wrapped!(StreamDescriptorSurfaceCreateFlagsGGP, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkHeadlessSurfaceCreateFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkHeadlessSurfaceCreateFlagsEXT.html>"]
pub struct HeadlessSurfaceCreateFlagsEXT(pub(crate) Flags); pub struct HeadlessSurfaceCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(HeadlessSurfaceCreateFlagsEXT, 0b0, Flags); vk_bitflags_wrapped!(HeadlessSurfaceCreateFlagsEXT, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkScreenSurfaceCreateFlagsQNX.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkScreenSurfaceCreateFlagsQNX.html>"]
pub struct ScreenSurfaceCreateFlagsQNX(pub(crate) Flags); pub struct ScreenSurfaceCreateFlagsQNX(pub(crate) Flags);
vk_bitflags_wrapped!(ScreenSurfaceCreateFlagsQNX, 0b0, Flags); vk_bitflags_wrapped!(ScreenSurfaceCreateFlagsQNX, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolTrimFlags.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolTrimFlags.html>"]
pub struct CommandPoolTrimFlags(pub(crate) Flags); pub struct CommandPoolTrimFlags(pub(crate) Flags);
vk_bitflags_wrapped!(CommandPoolTrimFlags, 0b0, Flags); vk_bitflags_wrapped!(CommandPoolTrimFlags, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportSwizzleStateCreateFlagsNV.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportSwizzleStateCreateFlagsNV.html>"]
pub struct PipelineViewportSwizzleStateCreateFlagsNV(pub(crate) Flags); pub struct PipelineViewportSwizzleStateCreateFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, 0b0, Flags); vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDiscardRectangleStateCreateFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDiscardRectangleStateCreateFlagsEXT.html>"]
pub struct PipelineDiscardRectangleStateCreateFlagsEXT(pub(crate) Flags); pub struct PipelineDiscardRectangleStateCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, 0b0, Flags); vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageToColorStateCreateFlagsNV.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageToColorStateCreateFlagsNV.html>"]
pub struct PipelineCoverageToColorStateCreateFlagsNV(pub(crate) Flags); pub struct PipelineCoverageToColorStateCreateFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, 0b0, Flags); vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageModulationStateCreateFlagsNV.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageModulationStateCreateFlagsNV.html>"]
pub struct PipelineCoverageModulationStateCreateFlagsNV(pub(crate) Flags); pub struct PipelineCoverageModulationStateCreateFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, 0b0, Flags); vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageReductionStateCreateFlagsNV.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageReductionStateCreateFlagsNV.html>"]
pub struct PipelineCoverageReductionStateCreateFlagsNV(pub(crate) Flags); pub struct PipelineCoverageReductionStateCreateFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineCoverageReductionStateCreateFlagsNV, 0b0, Flags); vk_bitflags_wrapped!(PipelineCoverageReductionStateCreateFlagsNV, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationCacheCreateFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationCacheCreateFlagsEXT.html>"]
pub struct ValidationCacheCreateFlagsEXT(pub(crate) Flags); pub struct ValidationCacheCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, 0b0, Flags); vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCreateFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCreateFlagsEXT.html>"]
pub struct DebugUtilsMessengerCreateFlagsEXT(pub(crate) Flags); pub struct DebugUtilsMessengerCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, 0b0, Flags); vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCallbackDataFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCallbackDataFlagsEXT.html>"]
pub struct DebugUtilsMessengerCallbackDataFlagsEXT(pub(crate) Flags); pub struct DebugUtilsMessengerCallbackDataFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, 0b0, Flags); vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemoryReportFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemoryReportFlagsEXT.html>"]
pub struct DeviceMemoryReportFlagsEXT(pub(crate) Flags); pub struct DeviceMemoryReportFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(DeviceMemoryReportFlagsEXT, 0b0, Flags); vk_bitflags_wrapped!(DeviceMemoryReportFlagsEXT, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationConservativeStateCreateFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationConservativeStateCreateFlagsEXT.html>"]
pub struct PipelineRasterizationConservativeStateCreateFlagsEXT(pub(crate) Flags); pub struct PipelineRasterizationConservativeStateCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!( vk_bitflags_wrapped!(PipelineRasterizationConservativeStateCreateFlagsEXT, Flags);
PipelineRasterizationConservativeStateCreateFlagsEXT,
0b0,
Flags
);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateStreamCreateFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateStreamCreateFlagsEXT.html>"]
pub struct PipelineRasterizationStateStreamCreateFlagsEXT(pub(crate) Flags); pub struct PipelineRasterizationStateStreamCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineRasterizationStateStreamCreateFlagsEXT, 0b0, Flags); vk_bitflags_wrapped!(PipelineRasterizationStateStreamCreateFlagsEXT, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateFlagsEXT.html>"]
pub struct PipelineRasterizationDepthClipStateCreateFlagsEXT(pub(crate) Flags); pub struct PipelineRasterizationDepthClipStateCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!( vk_bitflags_wrapped!(PipelineRasterizationDepthClipStateCreateFlagsEXT, Flags);
PipelineRasterizationDepthClipStateCreateFlagsEXT,
0b0,
Flags
);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoBeginCodingFlagsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoBeginCodingFlagsKHR.html>"]
pub struct VideoBeginCodingFlagsKHR(pub(crate) Flags); pub struct VideoBeginCodingFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(VideoBeginCodingFlagsKHR, 0b0, Flags); vk_bitflags_wrapped!(VideoBeginCodingFlagsKHR, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEndCodingFlagsKHR.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEndCodingFlagsKHR.html>"]
pub struct VideoEndCodingFlagsKHR(pub(crate) Flags); pub struct VideoEndCodingFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEndCodingFlagsKHR, 0b0, Flags); vk_bitflags_wrapped!(VideoEndCodingFlagsKHR, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264CreateFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264CreateFlagsEXT.html>"]
pub struct VideoDecodeH264CreateFlagsEXT(pub(crate) Flags); pub struct VideoDecodeH264CreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoDecodeH264CreateFlagsEXT, 0b0, Flags); vk_bitflags_wrapped!(VideoDecodeH264CreateFlagsEXT, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH265CreateFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH265CreateFlagsEXT.html>"]
pub struct VideoDecodeH265CreateFlagsEXT(pub(crate) Flags); pub struct VideoDecodeH265CreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoDecodeH265CreateFlagsEXT, 0b0, Flags); vk_bitflags_wrapped!(VideoDecodeH265CreateFlagsEXT, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265CapabilityFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265CapabilityFlagsEXT.html>"]
pub struct VideoEncodeH265CapabilityFlagsEXT(pub(crate) Flags); pub struct VideoEncodeH265CapabilityFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH265CapabilityFlagsEXT, 0b0, Flags); vk_bitflags_wrapped!(VideoEncodeH265CapabilityFlagsEXT, Flags);
#[repr(transparent)] #[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265CreateFlagsEXT.html>"] #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265CreateFlagsEXT.html>"]
pub struct VideoEncodeH265CreateFlagsEXT(pub(crate) Flags); pub struct VideoEncodeH265CreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH265CreateFlagsEXT, 0b0, Flags); vk_bitflags_wrapped!(VideoEncodeH265CreateFlagsEXT, Flags);
define_handle!( define_handle!(
Instance, Instance,
INSTANCE, INSTANCE,

25
ash/src/vk/macros.rs
View file

@ -1,6 +1,6 @@
#[macro_export] #[macro_export]
macro_rules! vk_bitflags_wrapped { macro_rules! vk_bitflags_wrapped {
($ name : ident , $ all : expr , $ flag_type : ty) => { ($ name : ident , $ flag_type : ty) => {
impl Default for $name { impl Default for $name {
fn default() -> Self { fn default() -> Self {
Self(0) Self(0)
@ -12,10 +12,6 @@ macro_rules! vk_bitflags_wrapped {
Self(0) Self(0)
} }
#[inline] #[inline]
pub const fn all() -> Self {
Self($all)
}
#[inline]
pub const fn from_raw(x: $flag_type) -> Self { pub const fn from_raw(x: $flag_type) -> Self {
Self(x) Self(x)
} }
@ -28,10 +24,6 @@ macro_rules! vk_bitflags_wrapped {
self == Self::empty() self == Self::empty()
} }
#[inline] #[inline]
pub fn is_all(self) -> bool {
self & Self::all() == Self::all()
}
#[inline]
pub fn intersects(self, other: Self) -> bool { pub fn intersects(self, other: Self) -> bool {
self & other != Self::empty() self & other != Self::empty()
} }
@ -80,24 +72,11 @@ macro_rules! vk_bitflags_wrapped {
*self = *self ^ rhs *self = *self ^ rhs
} }
} }
impl ::std::ops::Sub for $name {
type Output = Self;
#[inline]
fn sub(self, rhs: Self) -> Self {
self & !rhs
}
}
impl ::std::ops::SubAssign for $name {
#[inline]
fn sub_assign(&mut self, rhs: Self) {
*self = *self - rhs
}
}
impl ::std::ops::Not for $name { impl ::std::ops::Not for $name {
type Output = Self; type Output = Self;
#[inline] #[inline]
fn not(self) -> Self { fn not(self) -> Self {
self ^ Self::all() Self(!self.0)
} }
} }
}; };

5
examples/src/bin/texture.rs
View file

@ -667,7 +667,10 @@ fn main() {
src_alpha_blend_factor: vk::BlendFactor::ZERO, src_alpha_blend_factor: vk::BlendFactor::ZERO,
dst_alpha_blend_factor: vk::BlendFactor::ZERO, dst_alpha_blend_factor: vk::BlendFactor::ZERO,
alpha_blend_op: vk::BlendOp::ADD, alpha_blend_op: vk::BlendOp::ADD,
color_write_mask: vk::ColorComponentFlags::all(), color_write_mask: vk::ColorComponentFlags::R
| vk::ColorComponentFlags::G
| vk::ColorComponentFlags::B
| vk::ColorComponentFlags::A,
}]; }];
let color_blend_state = vk::PipelineColorBlendStateCreateInfo::builder() let color_blend_state = vk::PipelineColorBlendStateCreateInfo::builder()
.logic_op(vk::LogicOp::CLEAR) .logic_op(vk::LogicOp::CLEAR)

5
examples/src/bin/triangle.rs
View file

@ -324,7 +324,10 @@ fn main() {
src_alpha_blend_factor: vk::BlendFactor::ZERO, src_alpha_blend_factor: vk::BlendFactor::ZERO,
dst_alpha_blend_factor: vk::BlendFactor::ZERO, dst_alpha_blend_factor: vk::BlendFactor::ZERO,
alpha_blend_op: vk::BlendOp::ADD, alpha_blend_op: vk::BlendOp::ADD,
color_write_mask: vk::ColorComponentFlags::all(), color_write_mask: vk::ColorComponentFlags::R
| vk::ColorComponentFlags::G
| vk::ColorComponentFlags::B
| vk::ColorComponentFlags::A,
}]; }];
let color_blend_state = vk::PipelineColorBlendStateCreateInfo::builder() let color_blend_state = vk::PipelineColorBlendStateCreateInfo::builder()
.logic_op(vk::LogicOp::CLEAR) .logic_op(vk::LogicOp::CLEAR)

6
examples/src/lib.rs
View file

@ -242,7 +242,11 @@ impl ExampleBase {
| vk::DebugUtilsMessageSeverityFlagsEXT::WARNING | vk::DebugUtilsMessageSeverityFlagsEXT::WARNING
| vk::DebugUtilsMessageSeverityFlagsEXT::INFO, | vk::DebugUtilsMessageSeverityFlagsEXT::INFO,
) )
.message_type(vk::DebugUtilsMessageTypeFlagsEXT::all()) .message_type(
vk::DebugUtilsMessageTypeFlagsEXT::GENERAL
| vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION
| vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE,
)
.pfn_user_callback(Some(vulkan_debug_callback)); .pfn_user_callback(Some(vulkan_debug_callback));
let debug_utils_loader = DebugUtils::new(&entry, &instance); let debug_utils_loader = DebugUtils::new(&entry, &instance);

41
generator/src/lib.rs
View file

@ -224,7 +224,7 @@ pub fn vk_bitflags_wrapped_macro() -> TokenStream {
quote! { quote! {
#[macro_export] #[macro_export]
macro_rules! vk_bitflags_wrapped { macro_rules! vk_bitflags_wrapped {
($name: ident, $all: expr, $flag_type: ty) => { ($name: ident, $flag_type: ty) => {
impl Default for $name { impl Default for $name {
fn default() -> Self { fn default() -> Self {
@ -238,11 +238,6 @@ pub fn vk_bitflags_wrapped_macro() -> TokenStream {
Self(0) Self(0)
} }
#[inline]
pub const fn all() -> Self {
Self($all)
}
#[inline] #[inline]
pub const fn from_raw(x: $flag_type) -> Self { Self(x) } pub const fn from_raw(x: $flag_type) -> Self { Self(x) }
@ -254,11 +249,6 @@ pub fn vk_bitflags_wrapped_macro() -> TokenStream {
self == Self::empty() self == Self::empty()
} }
#[inline]
pub fn is_all(self) -> bool {
self & Self::all() == Self::all()
}
#[inline] #[inline]
pub fn intersects(self, other: Self) -> bool { pub fn intersects(self, other: Self) -> bool {
self & other != Self::empty() self & other != Self::empty()
@ -319,28 +309,12 @@ pub fn vk_bitflags_wrapped_macro() -> TokenStream {
} }
} }
impl ::std::ops::Sub for $name {
type Output = Self;
#[inline]
fn sub(self, rhs: Self) -> Self {
self & !rhs
}
}
impl ::std::ops::SubAssign for $name {
#[inline]
fn sub_assign(&mut self, rhs: Self) {
*self = *self - rhs
}
}
impl ::std::ops::Not for $name { impl ::std::ops::Not for $name {
type Output = Self; type Output = Self;
#[inline] #[inline]
fn not(self) -> Self { fn not(self) -> Self {
self ^ Self::all() Self(!self.0)
} }
} }
} }
@ -1359,7 +1333,7 @@ pub fn generate_bitmask(
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = #khronos_link] #[doc = #khronos_link]
pub struct #ident(pub(crate) #type_); pub struct #ident(pub(crate) #type_);
vk_bitflags_wrapped!(#ident, 0b0, #type_); vk_bitflags_wrapped!(#ident, #type_);
}) })
} }
@ -1538,19 +1512,12 @@ pub fn generate_enum<'a>(
if clean_name.contains("Bit") { if clean_name.contains("Bit") {
let ident = format_ident!("{}", _name.as_str()); let ident = format_ident!("{}", _name.as_str());
let all_bits = constants
.iter()
.filter_map(|constant| constant.constant(name).value())
.fold(0, |acc, next| acc | next.bits());
let type_ = if enum_.bitwidth == Some(64u32) { let type_ = if enum_.bitwidth == Some(64u32) {
quote!(Flags64) quote!(Flags64)
} else { } else {
quote!(Flags) quote!(Flags)
}; };
let bit_string = format!("{:b}", all_bits);
let bit_string = interleave_number('_', 4, &bit_string);
let all_bits_term = syn::LitInt::new(&format!("0b{}", bit_string), Span::call_site());
if !bitflags_cache.insert(ident.clone()) { if !bitflags_cache.insert(ident.clone()) {
EnumType::Bitflags(quote! {}) EnumType::Bitflags(quote! {})
@ -1561,7 +1528,7 @@ pub fn generate_enum<'a>(
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = #khronos_link] #[doc = #khronos_link]
pub struct #ident(pub(crate) #type_); pub struct #ident(pub(crate) #type_);
vk_bitflags_wrapped!(#ident, #all_bits_term, #type_); vk_bitflags_wrapped!(#ident, #type_);
#impl_bitflags #impl_bitflags
}; };
EnumType::Bitflags(q) EnumType::Bitflags(q)