From 2e9fb0816c6ee8e44ae5d9a01230a2787236371d Mon Sep 17 00:00:00 2001 From: Joshua Simmons Date: Sun, 5 Nov 2023 12:33:43 +0100 Subject: [PATCH] vulkan-sys: Use macro to generate flags impls Replace find-and-replace "we've got macros at home" with actual macros, and additionally fix a minor clippy lint about the structure of the clone impl. --- libs/ffi/vulkan-sys/src/flags.rs | 6441 ++---------------------------- 1 file changed, 257 insertions(+), 6184 deletions(-) diff --git a/libs/ffi/vulkan-sys/src/flags.rs b/libs/ffi/vulkan-sys/src/flags.rs index 1821fd8..8db0c98 100644 --- a/libs/ffi/vulkan-sys/src/flags.rs +++ b/libs/ffi/vulkan-sys/src/flags.rs @@ -870,6187 +870,260 @@ impl PipelineStageFlags2 { pub const INVOCATION_MASK_HUAWEI: Self = Self(0x10000000000); } -// Impls - -// InstanceCreateFlags -// XcbSurfaceCreateFlagsKHR -// XlibSurfaceCreateFlagsKHR -// WaylandSurfaceCreateFlagsKHR -// SampleCountFlags -// MemoryPropertyFlags -// MemoryHeapFlags -// MemoryMapFlags -// ImageAspectFlags -// SparseMemoryBindFlags -// SparseImageFormatFlags -// QueueFlags -// ImageUsageFlags -// ImageCreateFlags -// FormatFeatureFlags -// PipelineStageFlags -// SurfaceTransformFlagsKHR -// SwapchainCreateFlagsKHR -// CompositeAlphaFlagsKHR -// ImageViewCreateFlags -// CommandPoolCreateFlags -// CommandPoolResetFlags -// CommandBufferResetFlags -// CommandBufferUsageFlags -// QueryControlFlags -// QueryResultFlags -// QueryPipelineStatisticFlags -// AttachmentDescriptionFlags -// AccessFlags -// DependencyFlags -// SubpassDescriptionFlags -// RenderPassCreateFlags -// FramebufferCreateFlags -// FenceCreateFlags -// SemaphoreCreateFlags -// ShaderModuleCreateFlags -// ShaderStageFlags -// DescriptorSetLayoutCreateFlags -// StencilFaceFlags -// CullModeFlags -// DescriptorPoolCreateFlags -// DescriptorPoolResetFlags -// SamplerCreateFlags -// PipelineLayoutCreateFlags -// PipelineCacheCreateFlags -// PipelineDepthStencilStateCreateFlags -// PipelineDynamicStateCreateFlags -// PipelineColorBlendStateCreateFlags -// PipelineMultisampleStateCreateFlags -// PipelineRasterizationStateCreateFlags -// PipelineViewportStateCreateFlags -// PipelineTessellationStateCreateFlags -// PipelineInputAssemblyStateCreateFlags -// PipelineVertexInputStateCreateFlags -// PipelineShaderStageCreateFlags -// PipelineCreateFlags -// ColorComponentFlags -// BufferCreateFlags -// BufferUsageFlags -// BufferViewCreateFlags -// SemaphoreWaitFlags -// ResolveModeFlags -// RenderingFlags -// SubgroupFeatureFlags -// SubmitFlags -// AccessFlags2 -// PipelineStageFlags2 - -// Reference Implementation For Flags. - -// impl Flags { -// #[inline] -// pub fn from_raw(value: u32) -> Self { -// Self(value) -// } - -// #[inline] -// pub fn as_raw(self) -> u32 { -// self.0 -// } - -// #[inline] -// pub fn intersects(self, rhs: Self) -> bool { -// self.0 & rhs.0 != 0 -// } - -// #[inline] -// pub fn contains(self, rhs: Self) -> bool { -// self.0 & rhs.0 == rhs.0 -// } - -// #[inline] -// pub fn cardinality(self) -> u32 { -// self.0.count_ones() -// } -// } - -// impl Clone for Flags { -// fn clone(&self) -> Self { -// Self(self.0) -// } -// } - -// impl Copy for Flags {} - -// impl Default for Flags { -// fn default() -> Self { -// Self(0) -// } -// } - -// impl PartialEq for Flags { -// fn eq(&self, rhs: &Self) -> bool { -// self.0 == rhs.0 -// } -// } - -// impl Eq for Flags {} - -// impl std::ops::BitOr for Flags { -// type Output = Self; -// fn bitor(self, rhs: Self) -> Self::Output { -// Self(self.0 | rhs.0) -// } -// } - -// impl std::ops::BitOrAssign for Flags { -// fn bitor_assign(&mut self, rhs: Self) { -// self.0 |= rhs.0 -// } -// } - -// impl std::ops::BitAnd for Flags { -// type Output = Self; -// fn bitand(self, rhs: Self) -> Self::Output { -// Self(self.0 & rhs.0) -// } -// } - -// impl std::ops::BitAndAssign for Flags { -// fn bitand_assign(&mut self, rhs: Self) { -// self.0 &= rhs.0 -// } -// } - -// impl std::ops::BitXor for Flags { -// type Output = Self; -// fn bitxor(self, rhs: Self) -> Self::Output { -// Self(self.0 ^ rhs.0) -// } -// } - -// impl std::ops::BitXorAssign for Flags { -// fn bitxor_assign(&mut self, rhs: Self) { -// self.0 ^= rhs.0 -// } -// } - -impl XcbSurfaceCreateFlagsKHR { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for XcbSurfaceCreateFlagsKHR { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for XcbSurfaceCreateFlagsKHR {} - -impl Default for XcbSurfaceCreateFlagsKHR { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for XcbSurfaceCreateFlagsKHR { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for XcbSurfaceCreateFlagsKHR {} - -impl std::ops::BitOr for XcbSurfaceCreateFlagsKHR { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for XcbSurfaceCreateFlagsKHR { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for XcbSurfaceCreateFlagsKHR { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for XcbSurfaceCreateFlagsKHR { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for XcbSurfaceCreateFlagsKHR { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for XcbSurfaceCreateFlagsKHR { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl XlibSurfaceCreateFlagsKHR { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for XlibSurfaceCreateFlagsKHR { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for XlibSurfaceCreateFlagsKHR {} - -impl Default for XlibSurfaceCreateFlagsKHR { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for XlibSurfaceCreateFlagsKHR { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for XlibSurfaceCreateFlagsKHR {} - -impl std::ops::BitOr for XlibSurfaceCreateFlagsKHR { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for XlibSurfaceCreateFlagsKHR { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for XlibSurfaceCreateFlagsKHR { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for XlibSurfaceCreateFlagsKHR { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for XlibSurfaceCreateFlagsKHR { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for XlibSurfaceCreateFlagsKHR { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl WaylandSurfaceCreateFlagsKHR { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for WaylandSurfaceCreateFlagsKHR { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for WaylandSurfaceCreateFlagsKHR {} - -impl Default for WaylandSurfaceCreateFlagsKHR { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for WaylandSurfaceCreateFlagsKHR { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for WaylandSurfaceCreateFlagsKHR {} - -impl std::ops::BitOr for WaylandSurfaceCreateFlagsKHR { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for WaylandSurfaceCreateFlagsKHR { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for WaylandSurfaceCreateFlagsKHR { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for WaylandSurfaceCreateFlagsKHR { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for WaylandSurfaceCreateFlagsKHR { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for WaylandSurfaceCreateFlagsKHR { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl PipelineStageFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineStageFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineStageFlags {} - -impl Default for PipelineStageFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineStageFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineStageFlags {} - -impl std::ops::BitOr for PipelineStageFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineStageFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineStageFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineStageFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineStageFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineStageFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl InstanceCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for InstanceCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for InstanceCreateFlags {} - -impl Default for InstanceCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for InstanceCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for InstanceCreateFlags {} - -impl std::ops::BitOr for InstanceCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for InstanceCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for InstanceCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for InstanceCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for InstanceCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for InstanceCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl DeviceCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for DeviceCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for DeviceCreateFlags {} - -impl Default for DeviceCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for DeviceCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for DeviceCreateFlags {} - -impl std::ops::BitOr for DeviceCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for DeviceCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for DeviceCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for DeviceCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for DeviceCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for DeviceCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl DeviceQueueCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for DeviceQueueCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for DeviceQueueCreateFlags {} - -impl Default for DeviceQueueCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for DeviceQueueCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for DeviceQueueCreateFlags {} - -impl std::ops::BitOr for DeviceQueueCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for DeviceQueueCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for DeviceQueueCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for DeviceQueueCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for DeviceQueueCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for DeviceQueueCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl SampleCountFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for SampleCountFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for SampleCountFlags {} - -impl Default for SampleCountFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for SampleCountFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for SampleCountFlags {} - -impl std::ops::BitOr for SampleCountFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for SampleCountFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for SampleCountFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for SampleCountFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for SampleCountFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for SampleCountFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl MemoryPropertyFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for MemoryPropertyFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for MemoryPropertyFlags {} - -impl Default for MemoryPropertyFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for MemoryPropertyFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for MemoryPropertyFlags {} - -impl std::ops::BitOr for MemoryPropertyFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for MemoryPropertyFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for MemoryPropertyFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for MemoryPropertyFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for MemoryPropertyFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for MemoryPropertyFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl MemoryHeapFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for MemoryHeapFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for MemoryHeapFlags {} - -impl Default for MemoryHeapFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for MemoryHeapFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for MemoryHeapFlags {} - -impl std::ops::BitOr for MemoryHeapFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for MemoryHeapFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for MemoryHeapFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for MemoryHeapFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for MemoryHeapFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for MemoryHeapFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl MemoryMapFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for MemoryMapFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for MemoryMapFlags {} - -impl Default for MemoryMapFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for MemoryMapFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for MemoryMapFlags {} - -impl std::ops::BitOr for MemoryMapFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for MemoryMapFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for MemoryMapFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for MemoryMapFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for MemoryMapFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for MemoryMapFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl ImageAspectFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for ImageAspectFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for ImageAspectFlags {} - -impl Default for ImageAspectFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for ImageAspectFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for ImageAspectFlags {} - -impl std::ops::BitOr for ImageAspectFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for ImageAspectFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for ImageAspectFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for ImageAspectFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for ImageAspectFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for ImageAspectFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl SparseMemoryBindFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for SparseMemoryBindFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for SparseMemoryBindFlags {} - -impl Default for SparseMemoryBindFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for SparseMemoryBindFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for SparseMemoryBindFlags {} - -impl std::ops::BitOr for SparseMemoryBindFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for SparseMemoryBindFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for SparseMemoryBindFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for SparseMemoryBindFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for SparseMemoryBindFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for SparseMemoryBindFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl SparseImageFormatFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for SparseImageFormatFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for SparseImageFormatFlags {} - -impl Default for SparseImageFormatFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for SparseImageFormatFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for SparseImageFormatFlags {} - -impl std::ops::BitOr for SparseImageFormatFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for SparseImageFormatFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for SparseImageFormatFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for SparseImageFormatFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for SparseImageFormatFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for SparseImageFormatFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl QueueFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for QueueFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for QueueFlags {} - -impl Default for QueueFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for QueueFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for QueueFlags {} - -impl std::ops::BitOr for QueueFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for QueueFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for QueueFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for QueueFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for QueueFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for QueueFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl ImageUsageFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for ImageUsageFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for ImageUsageFlags {} - -impl Default for ImageUsageFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for ImageUsageFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for ImageUsageFlags {} - -impl std::ops::BitOr for ImageUsageFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for ImageUsageFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for ImageUsageFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for ImageUsageFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for ImageUsageFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for ImageUsageFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl ImageCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for ImageCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for ImageCreateFlags {} - -impl Default for ImageCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for ImageCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for ImageCreateFlags {} - -impl std::ops::BitOr for ImageCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for ImageCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for ImageCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for ImageCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for ImageCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for ImageCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl FormatFeatureFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for FormatFeatureFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for FormatFeatureFlags {} - -impl Default for FormatFeatureFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for FormatFeatureFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for FormatFeatureFlags {} - -impl std::ops::BitOr for FormatFeatureFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for FormatFeatureFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for FormatFeatureFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for FormatFeatureFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for FormatFeatureFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for FormatFeatureFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl SurfaceTransformFlagsKHR { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for SurfaceTransformFlagsKHR { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for SurfaceTransformFlagsKHR {} - -impl Default for SurfaceTransformFlagsKHR { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for SurfaceTransformFlagsKHR { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for SurfaceTransformFlagsKHR {} - -impl std::ops::BitOr for SurfaceTransformFlagsKHR { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for SurfaceTransformFlagsKHR { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for SurfaceTransformFlagsKHR { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for SurfaceTransformFlagsKHR { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for SurfaceTransformFlagsKHR { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for SurfaceTransformFlagsKHR { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl SwapchainCreateFlagsKHR { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for SwapchainCreateFlagsKHR { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for SwapchainCreateFlagsKHR {} - -impl Default for SwapchainCreateFlagsKHR { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for SwapchainCreateFlagsKHR { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for SwapchainCreateFlagsKHR {} - -impl std::ops::BitOr for SwapchainCreateFlagsKHR { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for SwapchainCreateFlagsKHR { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for SwapchainCreateFlagsKHR { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for SwapchainCreateFlagsKHR { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for SwapchainCreateFlagsKHR { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for SwapchainCreateFlagsKHR { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl CompositeAlphaFlagsKHR { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for CompositeAlphaFlagsKHR { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for CompositeAlphaFlagsKHR {} - -impl Default for CompositeAlphaFlagsKHR { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for CompositeAlphaFlagsKHR { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for CompositeAlphaFlagsKHR {} - -impl std::ops::BitOr for CompositeAlphaFlagsKHR { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for CompositeAlphaFlagsKHR { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for CompositeAlphaFlagsKHR { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for CompositeAlphaFlagsKHR { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for CompositeAlphaFlagsKHR { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for CompositeAlphaFlagsKHR { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl ImageViewCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for ImageViewCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for ImageViewCreateFlags {} - -impl Default for ImageViewCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for ImageViewCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for ImageViewCreateFlags {} - -impl std::ops::BitOr for ImageViewCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for ImageViewCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for ImageViewCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for ImageViewCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for ImageViewCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for ImageViewCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl CommandPoolCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for CommandPoolCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for CommandPoolCreateFlags {} - -impl Default for CommandPoolCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for CommandPoolCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for CommandPoolCreateFlags {} - -impl std::ops::BitOr for CommandPoolCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for CommandPoolCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for CommandPoolCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for CommandPoolCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for CommandPoolCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for CommandPoolCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl CommandPoolResetFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for CommandPoolResetFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for CommandPoolResetFlags {} - -impl Default for CommandPoolResetFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for CommandPoolResetFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for CommandPoolResetFlags {} - -impl std::ops::BitOr for CommandPoolResetFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for CommandPoolResetFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for CommandPoolResetFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for CommandPoolResetFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for CommandPoolResetFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for CommandPoolResetFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl CommandBufferResetFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for CommandBufferResetFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for CommandBufferResetFlags {} - -impl Default for CommandBufferResetFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for CommandBufferResetFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for CommandBufferResetFlags {} - -impl std::ops::BitOr for CommandBufferResetFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for CommandBufferResetFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for CommandBufferResetFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for CommandBufferResetFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for CommandBufferResetFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for CommandBufferResetFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl CommandBufferUsageFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for CommandBufferUsageFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for CommandBufferUsageFlags {} - -impl Default for CommandBufferUsageFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for CommandBufferUsageFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for CommandBufferUsageFlags {} - -impl std::ops::BitOr for CommandBufferUsageFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for CommandBufferUsageFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for CommandBufferUsageFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for CommandBufferUsageFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for CommandBufferUsageFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for CommandBufferUsageFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl QueryControlFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for QueryControlFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for QueryControlFlags {} - -impl Default for QueryControlFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for QueryControlFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for QueryControlFlags {} - -impl std::ops::BitOr for QueryControlFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for QueryControlFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for QueryControlFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for QueryControlFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for QueryControlFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for QueryControlFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl QueryResultFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for QueryResultFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for QueryResultFlags {} - -impl Default for QueryResultFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for QueryResultFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for QueryResultFlags {} - -impl std::ops::BitOr for QueryResultFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for QueryResultFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for QueryResultFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for QueryResultFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for QueryResultFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for QueryResultFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl QueryPipelineStatisticFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for QueryPipelineStatisticFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for QueryPipelineStatisticFlags {} - -impl Default for QueryPipelineStatisticFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for QueryPipelineStatisticFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for QueryPipelineStatisticFlags {} - -impl std::ops::BitOr for QueryPipelineStatisticFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for QueryPipelineStatisticFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for QueryPipelineStatisticFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for QueryPipelineStatisticFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for QueryPipelineStatisticFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for QueryPipelineStatisticFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl AttachmentDescriptionFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for AttachmentDescriptionFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for AttachmentDescriptionFlags {} - -impl Default for AttachmentDescriptionFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for AttachmentDescriptionFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for AttachmentDescriptionFlags {} - -impl std::ops::BitOr for AttachmentDescriptionFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for AttachmentDescriptionFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for AttachmentDescriptionFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for AttachmentDescriptionFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for AttachmentDescriptionFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for AttachmentDescriptionFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl AccessFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for AccessFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for AccessFlags {} - -impl Default for AccessFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for AccessFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for AccessFlags {} - -impl std::ops::BitOr for AccessFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for AccessFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for AccessFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for AccessFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for AccessFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for AccessFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl DependencyFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for DependencyFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for DependencyFlags {} - -impl Default for DependencyFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for DependencyFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for DependencyFlags {} - -impl std::ops::BitOr for DependencyFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for DependencyFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for DependencyFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for DependencyFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for DependencyFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for DependencyFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl SubpassDescriptionFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for SubpassDescriptionFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for SubpassDescriptionFlags {} - -impl Default for SubpassDescriptionFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for SubpassDescriptionFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for SubpassDescriptionFlags {} - -impl std::ops::BitOr for SubpassDescriptionFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for SubpassDescriptionFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for SubpassDescriptionFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for SubpassDescriptionFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for SubpassDescriptionFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for SubpassDescriptionFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl RenderPassCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for RenderPassCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for RenderPassCreateFlags {} - -impl Default for RenderPassCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for RenderPassCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for RenderPassCreateFlags {} - -impl std::ops::BitOr for RenderPassCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for RenderPassCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for RenderPassCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for RenderPassCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for RenderPassCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for RenderPassCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl FramebufferCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for FramebufferCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for FramebufferCreateFlags {} - -impl Default for FramebufferCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for FramebufferCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for FramebufferCreateFlags {} - -impl std::ops::BitOr for FramebufferCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for FramebufferCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for FramebufferCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for FramebufferCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for FramebufferCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for FramebufferCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl FenceCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for FenceCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for FenceCreateFlags {} - -impl Default for FenceCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for FenceCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for FenceCreateFlags {} - -impl std::ops::BitOr for FenceCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for FenceCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for FenceCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for FenceCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for FenceCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for FenceCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl SemaphoreCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for SemaphoreCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for SemaphoreCreateFlags {} - -impl Default for SemaphoreCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for SemaphoreCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for SemaphoreCreateFlags {} - -impl std::ops::BitOr for SemaphoreCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for SemaphoreCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for SemaphoreCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for SemaphoreCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for SemaphoreCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for SemaphoreCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl ShaderModuleCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for ShaderModuleCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for ShaderModuleCreateFlags {} - -impl Default for ShaderModuleCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for ShaderModuleCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for ShaderModuleCreateFlags {} - -impl std::ops::BitOr for ShaderModuleCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for ShaderModuleCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for ShaderModuleCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for ShaderModuleCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for ShaderModuleCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for ShaderModuleCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl ShaderStageFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for ShaderStageFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for ShaderStageFlags {} - -impl Default for ShaderStageFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for ShaderStageFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for ShaderStageFlags {} - -impl std::ops::BitOr for ShaderStageFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for ShaderStageFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for ShaderStageFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for ShaderStageFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for ShaderStageFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for ShaderStageFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl DescriptorSetLayoutCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for DescriptorSetLayoutCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for DescriptorSetLayoutCreateFlags {} - -impl Default for DescriptorSetLayoutCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for DescriptorSetLayoutCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for DescriptorSetLayoutCreateFlags {} - -impl std::ops::BitOr for DescriptorSetLayoutCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for DescriptorSetLayoutCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for DescriptorSetLayoutCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for DescriptorSetLayoutCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for DescriptorSetLayoutCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for DescriptorSetLayoutCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl StencilFaceFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for StencilFaceFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for StencilFaceFlags {} - -impl Default for StencilFaceFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for StencilFaceFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for StencilFaceFlags {} - -impl std::ops::BitOr for StencilFaceFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for StencilFaceFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for StencilFaceFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for StencilFaceFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for StencilFaceFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for StencilFaceFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl CullModeFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for CullModeFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for CullModeFlags {} - -impl Default for CullModeFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for CullModeFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for CullModeFlags {} - -impl std::ops::BitOr for CullModeFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for CullModeFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for CullModeFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for CullModeFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for CullModeFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for CullModeFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl DescriptorPoolCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for DescriptorPoolCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for DescriptorPoolCreateFlags {} - -impl Default for DescriptorPoolCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for DescriptorPoolCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for DescriptorPoolCreateFlags {} - -impl std::ops::BitOr for DescriptorPoolCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for DescriptorPoolCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for DescriptorPoolCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for DescriptorPoolCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for DescriptorPoolCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for DescriptorPoolCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl DescriptorPoolResetFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for DescriptorPoolResetFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for DescriptorPoolResetFlags {} - -impl Default for DescriptorPoolResetFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for DescriptorPoolResetFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for DescriptorPoolResetFlags {} - -impl std::ops::BitOr for DescriptorPoolResetFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for DescriptorPoolResetFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for DescriptorPoolResetFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for DescriptorPoolResetFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for DescriptorPoolResetFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for DescriptorPoolResetFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl SamplerCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for SamplerCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for SamplerCreateFlags {} - -impl Default for SamplerCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for SamplerCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for SamplerCreateFlags {} - -impl std::ops::BitOr for SamplerCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for SamplerCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for SamplerCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for SamplerCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for SamplerCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for SamplerCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl PipelineLayoutCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineLayoutCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineLayoutCreateFlags {} - -impl Default for PipelineLayoutCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineLayoutCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineLayoutCreateFlags {} - -impl std::ops::BitOr for PipelineLayoutCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineLayoutCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineLayoutCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineLayoutCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineLayoutCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineLayoutCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl PipelineCacheCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineCacheCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineCacheCreateFlags {} - -impl Default for PipelineCacheCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineCacheCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineCacheCreateFlags {} - -impl std::ops::BitOr for PipelineCacheCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineCacheCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineCacheCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineCacheCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineCacheCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineCacheCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl PipelineDepthStencilStateCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineDepthStencilStateCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineDepthStencilStateCreateFlags {} - -impl Default for PipelineDepthStencilStateCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineDepthStencilStateCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineDepthStencilStateCreateFlags {} - -impl std::ops::BitOr for PipelineDepthStencilStateCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineDepthStencilStateCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineDepthStencilStateCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineDepthStencilStateCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineDepthStencilStateCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineDepthStencilStateCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl PipelineDynamicStateCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineDynamicStateCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineDynamicStateCreateFlags {} - -impl Default for PipelineDynamicStateCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineDynamicStateCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineDynamicStateCreateFlags {} - -impl std::ops::BitOr for PipelineDynamicStateCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineDynamicStateCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineDynamicStateCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineDynamicStateCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineDynamicStateCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineDynamicStateCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl PipelineColorBlendStateCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineColorBlendStateCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineColorBlendStateCreateFlags {} - -impl Default for PipelineColorBlendStateCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineColorBlendStateCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineColorBlendStateCreateFlags {} - -impl std::ops::BitOr for PipelineColorBlendStateCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineColorBlendStateCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineColorBlendStateCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineColorBlendStateCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineColorBlendStateCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineColorBlendStateCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl PipelineMultisampleStateCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineMultisampleStateCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineMultisampleStateCreateFlags {} - -impl Default for PipelineMultisampleStateCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineMultisampleStateCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineMultisampleStateCreateFlags {} - -impl std::ops::BitOr for PipelineMultisampleStateCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineMultisampleStateCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineMultisampleStateCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineMultisampleStateCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineMultisampleStateCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineMultisampleStateCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl PipelineRasterizationStateCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineRasterizationStateCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineRasterizationStateCreateFlags {} - -impl Default for PipelineRasterizationStateCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineRasterizationStateCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineRasterizationStateCreateFlags {} - -impl std::ops::BitOr for PipelineRasterizationStateCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineRasterizationStateCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineRasterizationStateCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineRasterizationStateCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineRasterizationStateCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineRasterizationStateCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl PipelineViewportStateCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineViewportStateCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineViewportStateCreateFlags {} - -impl Default for PipelineViewportStateCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineViewportStateCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineViewportStateCreateFlags {} - -impl std::ops::BitOr for PipelineViewportStateCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineViewportStateCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineViewportStateCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineViewportStateCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineViewportStateCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineViewportStateCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl PipelineTessellationStateCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineTessellationStateCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineTessellationStateCreateFlags {} - -impl Default for PipelineTessellationStateCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineTessellationStateCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineTessellationStateCreateFlags {} - -impl std::ops::BitOr for PipelineTessellationStateCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineTessellationStateCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineTessellationStateCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineTessellationStateCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineTessellationStateCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineTessellationStateCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl PipelineInputAssemblyStateCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineInputAssemblyStateCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineInputAssemblyStateCreateFlags {} - -impl Default for PipelineInputAssemblyStateCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineInputAssemblyStateCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineInputAssemblyStateCreateFlags {} - -impl std::ops::BitOr for PipelineInputAssemblyStateCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineInputAssemblyStateCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineInputAssemblyStateCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineInputAssemblyStateCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineInputAssemblyStateCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineInputAssemblyStateCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl PipelineVertexInputStateCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineVertexInputStateCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineVertexInputStateCreateFlags {} - -impl Default for PipelineVertexInputStateCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineVertexInputStateCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineVertexInputStateCreateFlags {} - -impl std::ops::BitOr for PipelineVertexInputStateCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineVertexInputStateCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineVertexInputStateCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineVertexInputStateCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineVertexInputStateCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineVertexInputStateCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl PipelineShaderStageCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineShaderStageCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineShaderStageCreateFlags {} - -impl Default for PipelineShaderStageCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineShaderStageCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineShaderStageCreateFlags {} - -impl std::ops::BitOr for PipelineShaderStageCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineShaderStageCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineShaderStageCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineShaderStageCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineShaderStageCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineShaderStageCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl PipelineCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineCreateFlags {} - -impl Default for PipelineCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineCreateFlags {} - -impl std::ops::BitOr for PipelineCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl ColorComponentFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for ColorComponentFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for ColorComponentFlags {} - -impl Default for ColorComponentFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for ColorComponentFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for ColorComponentFlags {} - -impl std::ops::BitOr for ColorComponentFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for ColorComponentFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for ColorComponentFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for ColorComponentFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for ColorComponentFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for ColorComponentFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl BufferCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for BufferCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for BufferCreateFlags {} - -impl Default for BufferCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for BufferCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for BufferCreateFlags {} - -impl std::ops::BitOr for BufferCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for BufferCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for BufferCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for BufferCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for BufferCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for BufferCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl BufferUsageFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for BufferUsageFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for BufferUsageFlags {} - -impl Default for BufferUsageFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for BufferUsageFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for BufferUsageFlags {} - -impl std::ops::BitOr for BufferUsageFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for BufferUsageFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for BufferUsageFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for BufferUsageFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for BufferUsageFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for BufferUsageFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl BufferViewCreateFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for BufferViewCreateFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for BufferViewCreateFlags {} - -impl Default for BufferViewCreateFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for BufferViewCreateFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for BufferViewCreateFlags {} - -impl std::ops::BitOr for BufferViewCreateFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for BufferViewCreateFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for BufferViewCreateFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for BufferViewCreateFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for BufferViewCreateFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for BufferViewCreateFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl SemaphoreWaitFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for SemaphoreWaitFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for SemaphoreWaitFlags {} - -impl Default for SemaphoreWaitFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for SemaphoreWaitFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for SemaphoreWaitFlags {} - -impl std::ops::BitOr for SemaphoreWaitFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for SemaphoreWaitFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for SemaphoreWaitFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for SemaphoreWaitFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for SemaphoreWaitFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for SemaphoreWaitFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl ResolveModeFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for ResolveModeFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for ResolveModeFlags {} - -impl Default for ResolveModeFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for ResolveModeFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for ResolveModeFlags {} - -impl std::ops::BitOr for ResolveModeFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for ResolveModeFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for ResolveModeFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for ResolveModeFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for ResolveModeFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for ResolveModeFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl RenderingFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for RenderingFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for RenderingFlags {} - -impl Default for RenderingFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for RenderingFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for RenderingFlags {} - -impl std::ops::BitOr for RenderingFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for RenderingFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for RenderingFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for RenderingFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for RenderingFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for RenderingFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl SubgroupFeatureFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for SubgroupFeatureFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for SubgroupFeatureFlags {} - -impl Default for SubgroupFeatureFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for SubgroupFeatureFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for SubgroupFeatureFlags {} - -impl std::ops::BitOr for SubgroupFeatureFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for SubgroupFeatureFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for SubgroupFeatureFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for SubgroupFeatureFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for SubgroupFeatureFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for SubgroupFeatureFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} -impl SubmitFlags { - #[inline] - pub fn from_raw(value: u32) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u32 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for SubmitFlags { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for SubmitFlags {} - -impl Default for SubmitFlags { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for SubmitFlags { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for SubmitFlags {} - -impl std::ops::BitOr for SubmitFlags { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for SubmitFlags { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for SubmitFlags { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for SubmitFlags { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for SubmitFlags { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for SubmitFlags { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl PipelineStageFlags2 { - #[inline] - pub fn from_raw(value: u64) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u64 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for PipelineStageFlags2 { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for PipelineStageFlags2 {} - -impl Default for PipelineStageFlags2 { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for PipelineStageFlags2 { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for PipelineStageFlags2 {} - -impl std::ops::BitOr for PipelineStageFlags2 { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for PipelineStageFlags2 { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for PipelineStageFlags2 { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for PipelineStageFlags2 { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for PipelineStageFlags2 { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for PipelineStageFlags2 { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} - -impl AccessFlags2 { - #[inline] - pub fn from_raw(value: u64) -> Self { - Self(value) - } - - #[inline] - pub fn as_raw(self) -> u64 { - self.0 - } - - #[inline] - pub fn intersects(self, rhs: Self) -> bool { - self.0 & rhs.0 != 0 - } - - #[inline] - pub fn contains(self, rhs: Self) -> bool { - self.0 & rhs.0 == rhs.0 - } - - #[inline] - pub fn cardinality(self) -> u32 { - self.0.count_ones() - } -} - -impl Clone for AccessFlags2 { - fn clone(&self) -> Self { - Self(self.0) - } -} - -impl Copy for AccessFlags2 {} - -impl Default for AccessFlags2 { - fn default() -> Self { - Self(0) - } -} - -impl PartialEq for AccessFlags2 { - fn eq(&self, rhs: &Self) -> bool { - self.0 == rhs.0 - } -} - -impl Eq for AccessFlags2 {} - -impl std::ops::BitOr for AccessFlags2 { - type Output = Self; - fn bitor(self, rhs: Self) -> Self::Output { - Self(self.0 | rhs.0) - } -} - -impl std::ops::BitOrAssign for AccessFlags2 { - fn bitor_assign(&mut self, rhs: Self) { - self.0 |= rhs.0 - } -} - -impl std::ops::BitAnd for AccessFlags2 { - type Output = Self; - fn bitand(self, rhs: Self) -> Self::Output { - Self(self.0 & rhs.0) - } -} - -impl std::ops::BitAndAssign for AccessFlags2 { - fn bitand_assign(&mut self, rhs: Self) { - self.0 &= rhs.0 - } -} - -impl std::ops::BitXor for AccessFlags2 { - type Output = Self; - fn bitxor(self, rhs: Self) -> Self::Output { - Self(self.0 ^ rhs.0) - } -} - -impl std::ops::BitXorAssign for AccessFlags2 { - fn bitxor_assign(&mut self, rhs: Self) { - self.0 ^= rhs.0 - } -} +macro_rules! impl_flags_u32 { + ($($t:ty),+) => { + $( + impl $t { + #[inline] + pub fn from_raw(value: u32) -> Self { + Self(value) + } + + #[inline] + pub fn as_raw(self) -> u32 { + self.0 + } + + #[inline] + pub fn intersects(self, rhs: Self) -> bool { + self.0 & rhs.0 != 0 + } + + #[inline] + pub fn contains(self, rhs: Self) -> bool { + self.0 & rhs.0 == rhs.0 + } + + #[inline] + pub fn cardinality(self) -> u32 { + self.0.count_ones() + } + } + + impl Clone for $t { + fn clone(&self) -> Self { + *self + } + } + + impl Copy for $t {} + + impl Default for $t { + fn default() -> Self { + Self(0) + } + } + + impl PartialEq for $t { + fn eq(&self, rhs: &Self) -> bool { + self.0 == rhs.0 + } + } + + impl Eq for $t {} + + impl std::ops::BitOr for $t { + type Output = Self; + fn bitor(self, rhs: Self) -> Self::Output { + Self(self.0 | rhs.0) + } + } + + impl std::ops::BitOrAssign for $t { + fn bitor_assign(&mut self, rhs: Self) { + self.0 |= rhs.0 + } + } + + impl std::ops::BitAnd for $t { + type Output = Self; + fn bitand(self, rhs: Self) -> Self::Output { + Self(self.0 & rhs.0) + } + } + + impl std::ops::BitAndAssign for $t { + fn bitand_assign(&mut self, rhs: Self) { + self.0 &= rhs.0 + } + } + + impl std::ops::BitXor for $t { + type Output = Self; + fn bitxor(self, rhs: Self) -> Self::Output { + Self(self.0 ^ rhs.0) + } + } + + impl std::ops::BitXorAssign for $t { + fn bitxor_assign(&mut self, rhs: Self) { + self.0 ^= rhs.0 + } + } + )* + } +} + +macro_rules! impl_flags_u64 { + ($($t:ty),+) => { + $( + impl $t { + #[inline] + pub fn from_raw(value: u64) -> Self { + Self(value) + } + + #[inline] + pub fn as_raw(self) -> u64 { + self.0 + } + + #[inline] + pub fn intersects(self, rhs: Self) -> bool { + self.0 & rhs.0 != 0 + } + + #[inline] + pub fn contains(self, rhs: Self) -> bool { + self.0 & rhs.0 == rhs.0 + } + + #[inline] + pub fn cardinality(self) -> u32 { + self.0.count_ones() + } + } + + impl Clone for $t { + fn clone(&self) -> Self { + *self + } + } + + impl Copy for $t {} + + impl Default for $t { + fn default() -> Self { + Self(0) + } + } + + impl PartialEq for $t { + fn eq(&self, rhs: &Self) -> bool { + self.0 == rhs.0 + } + } + + impl Eq for $t {} + + impl std::ops::BitOr for $t { + type Output = Self; + fn bitor(self, rhs: Self) -> Self::Output { + Self(self.0 | rhs.0) + } + } + + impl std::ops::BitOrAssign for $t { + fn bitor_assign(&mut self, rhs: Self) { + self.0 |= rhs.0 + } + } + + impl std::ops::BitAnd for $t { + type Output = Self; + fn bitand(self, rhs: Self) -> Self::Output { + Self(self.0 & rhs.0) + } + } + + impl std::ops::BitAndAssign for $t { + fn bitand_assign(&mut self, rhs: Self) { + self.0 &= rhs.0 + } + } + + impl std::ops::BitXor for $t { + type Output = Self; + fn bitxor(self, rhs: Self) -> Self::Output { + Self(self.0 ^ rhs.0) + } + } + + impl std::ops::BitXorAssign for $t { + fn bitxor_assign(&mut self, rhs: Self) { + self.0 ^= rhs.0 + } + } + )* + } +} + +impl_flags_u32!( + InstanceCreateFlags, + XcbSurfaceCreateFlagsKHR, + XlibSurfaceCreateFlagsKHR, + WaylandSurfaceCreateFlagsKHR, + SampleCountFlags, + MemoryPropertyFlags, + MemoryHeapFlags, + MemoryMapFlags, + ImageAspectFlags, + SparseMemoryBindFlags, + SparseImageFormatFlags, + QueueFlags, + ImageUsageFlags, + ImageCreateFlags, + FormatFeatureFlags, + PipelineStageFlags, + SurfaceTransformFlagsKHR, + SwapchainCreateFlagsKHR, + CompositeAlphaFlagsKHR, + ImageViewCreateFlags, + CommandPoolCreateFlags, + CommandPoolResetFlags, + CommandBufferResetFlags, + CommandBufferUsageFlags, + QueryControlFlags, + QueryResultFlags, + QueryPipelineStatisticFlags, + AttachmentDescriptionFlags, + AccessFlags, + DependencyFlags, + SubpassDescriptionFlags, + RenderPassCreateFlags, + FramebufferCreateFlags, + FenceCreateFlags, + SemaphoreCreateFlags, + ShaderModuleCreateFlags, + ShaderStageFlags, + DescriptorSetLayoutCreateFlags, + StencilFaceFlags, + CullModeFlags, + DescriptorPoolCreateFlags, + DescriptorPoolResetFlags, + SamplerCreateFlags, + PipelineLayoutCreateFlags, + PipelineCacheCreateFlags, + PipelineDepthStencilStateCreateFlags, + PipelineDynamicStateCreateFlags, + PipelineColorBlendStateCreateFlags, + PipelineMultisampleStateCreateFlags, + PipelineRasterizationStateCreateFlags, + PipelineViewportStateCreateFlags, + PipelineTessellationStateCreateFlags, + PipelineInputAssemblyStateCreateFlags, + PipelineVertexInputStateCreateFlags, + PipelineShaderStageCreateFlags, + PipelineCreateFlags, + ColorComponentFlags, + BufferCreateFlags, + BufferUsageFlags, + BufferViewCreateFlags, + SemaphoreWaitFlags, + ResolveModeFlags, + RenderingFlags, + SubgroupFeatureFlags, + SubmitFlags +); + +impl_flags_u64!(AccessFlags2, PipelineStageFlags2); -- 2.49.0