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);
projects / josh / narcissus / commitdiff