| // Copyright (c) 2022 The Vulkano developers |
| // Licensed under the Apache License, Version 2.0 |
| // <LICENSE-APACHE or |
| // https://www.apache.org/licenses/LICENSE-2.0> or the MIT |
| // license <LICENSE-MIT or https://opensource.org/licenses/MIT>, |
| // at your option. All files in the project carrying such |
| // notice may not be copied, modified, or distributed except |
| // according to those terms. |
| |
| macro_rules! vulkan_bitflags { |
| { |
| $(#[doc = $ty_doc:literal])* |
| $ty:ident |
| $( impl { $($impls:item)* } )? |
| = $ty_ffi:ident($repr:ty); |
| |
| $( |
| $(#[doc = $flag_doc:literal])* |
| $flag_name:ident = $flag_name_ffi:ident, |
| )+ |
| } => { |
| $(#[doc = $ty_doc])* |
| #[derive(Clone, Copy, PartialEq, Eq, Hash)] |
| pub struct $ty($repr); |
| |
| impl $ty { |
| $( |
| $(#[doc = $flag_doc])* |
| pub const $flag_name: Self = Self(ash::vk::$ty_ffi::$flag_name_ffi.as_raw()); |
| )* |
| |
| #[doc = concat!("Returns a `", stringify!($ty), "` with none of the flags set.")] |
| #[inline] |
| pub const fn empty() -> Self { |
| Self(0) |
| } |
| |
| #[deprecated(since = "0.31.0", note = "Use `empty` instead.")] |
| #[doc = concat!("Returns a `", stringify!($ty), "` with none of the flags set.")] |
| #[inline] |
| pub const fn none() -> Self { |
| Self::empty() |
| } |
| |
| #[doc = concat!("Returns a `", stringify!($ty), "` with all of the flags set.")] |
| #[inline] |
| pub const fn all() -> Self { |
| Self(Self::all_raw()) |
| } |
| |
| const fn all_raw() -> $repr { |
| 0 |
| $( |
| | ash::vk::$ty_ffi::$flag_name_ffi.as_raw() |
| )* |
| } |
| |
| /// Returns whether no flags are set in `self`. |
| #[inline] |
| pub const fn is_empty(self) -> bool { |
| self.0 == 0 |
| } |
| |
| /// Returns whether any flags are set in both `self` and `other`. |
| #[inline] |
| pub const fn intersects(self, #[allow(unused_variables)] other: Self) -> bool { |
| self.0 & other.0 != 0 |
| } |
| |
| /// Returns whether all flags in `other` are set in `self`. |
| #[inline] |
| pub const fn contains(self, #[allow(unused_variables)] other: Self) -> bool { |
| self.0 & other.0 == other.0 |
| } |
| |
| /// Returns the union of `self` and `other`. |
| #[inline] |
| pub const fn union(self, #[allow(unused_variables)] other: Self) -> Self { |
| Self(self.0 | other.0) |
| } |
| |
| /// Returns the intersection of `self` and `other`. |
| #[inline] |
| pub const fn intersection(self, #[allow(unused_variables)] other: Self) -> Self { |
| Self(self.0 & other.0) |
| } |
| |
| /// Returns `self` without the flags set in `other`. |
| #[inline] |
| pub const fn difference(self, #[allow(unused_variables)] other: Self) -> Self { |
| Self(self.0 & !other.0) |
| } |
| |
| /// Returns the flags that are set in `self` or `other`, but not in both. |
| #[inline] |
| pub const fn symmetric_difference(self, #[allow(unused_variables)] other: Self) -> Self { |
| Self(self.0 ^ other.0) |
| } |
| |
| /// Returns the flags not in `self`. |
| #[inline] |
| pub const fn complement(self) -> Self { |
| Self(!self.0 & Self::all_raw()) |
| } |
| |
| $( $($impls)* )? |
| } |
| |
| impl Default for $ty { |
| #[inline] |
| fn default() -> Self { |
| Self::empty() |
| } |
| } |
| |
| impl std::fmt::Debug for $ty { |
| fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> { |
| #[allow(unused_mut)] |
| let mut written = false; |
| |
| $( |
| if self.intersects(Self::$flag_name) { |
| if written { |
| write!(f, " | ")?; |
| } |
| |
| write!(f, stringify!($flag_name))?; |
| written = true; |
| } |
| )* |
| |
| if !written { |
| write!(f, "empty()")?; |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl From<$ty> for ash::vk::$ty_ffi { |
| #[inline] |
| fn from(val: $ty) -> Self { |
| ash::vk::$ty_ffi::from_raw(val.0) |
| } |
| } |
| |
| impl From<ash::vk::$ty_ffi> for $ty { |
| #[inline] |
| fn from(val: ash::vk::$ty_ffi) -> Self { |
| Self(val.as_raw() & Self::all_raw()) |
| } |
| } |
| |
| impl std::ops::BitAnd for $ty { |
| type Output = Self; |
| |
| #[inline] |
| fn bitand(self, rhs: Self) -> Self { |
| self.intersection(rhs) |
| } |
| } |
| |
| impl std::ops::BitAndAssign for $ty { |
| #[inline] |
| fn bitand_assign(&mut self, rhs: Self) { |
| *self = self.intersection(rhs); |
| } |
| } |
| |
| impl std::ops::BitOr for $ty { |
| type Output = Self; |
| |
| #[inline] |
| fn bitor(self, rhs: Self) -> Self { |
| self.union(rhs) |
| } |
| } |
| |
| impl std::ops::BitOrAssign for $ty { |
| #[inline] |
| fn bitor_assign(&mut self, rhs: Self) { |
| *self = self.union(rhs); |
| } |
| } |
| |
| impl std::ops::BitXor for $ty { |
| type Output = Self; |
| |
| #[inline] |
| fn bitxor(self, rhs: Self) -> Self { |
| self.symmetric_difference(rhs) |
| } |
| } |
| |
| impl std::ops::BitXorAssign for $ty { |
| #[inline] |
| fn bitxor_assign(&mut self, rhs: Self) { |
| *self = self.symmetric_difference(rhs); |
| } |
| } |
| |
| impl std::ops::Sub for $ty { |
| type Output = Self; |
| |
| #[inline] |
| fn sub(self, rhs: Self) -> Self { |
| self.difference(rhs) |
| } |
| } |
| |
| impl std::ops::SubAssign for $ty { |
| #[inline] |
| fn sub_assign(&mut self, rhs: Self) { |
| *self = self.difference(rhs); |
| } |
| } |
| |
| impl std::ops::Not for $ty { |
| type Output = Self; |
| |
| #[inline] |
| fn not(self) -> Self { |
| self.complement() |
| } |
| } |
| }; |
| |
| { |
| #[non_exhaustive] |
| |
| $(#[doc = $ty_doc:literal])* |
| $ty:ident |
| $( impl { $($impls:item)* } )? |
| = $ty_ffi:ident($repr:ty); |
| |
| $( |
| $(#[doc = $flag_doc:literal])* |
| $flag_name:ident = $flag_name_ffi:ident |
| $({ |
| $(api_version: $api_version:ident,)? |
| $(features: [$($feature:ident),+ $(,)?],)? |
| $(device_extensions: [$($device_extension:ident),+ $(,)?],)? |
| $(instance_extensions: [$($instance_extension:ident),+ $(,)?],)? |
| })? |
| , |
| )* |
| } => { |
| $(#[doc = $ty_doc])* |
| #[derive(Clone, Copy, PartialEq, Eq, Hash)] |
| pub struct $ty($repr); |
| |
| impl $ty { |
| $( |
| $(#[doc = $flag_doc])* |
| pub const $flag_name: Self = Self(ash::vk::$ty_ffi::$flag_name_ffi.as_raw()); |
| )* |
| |
| #[doc = concat!("Returns a `", stringify!($ty), "` with none of the flags set.")] |
| #[inline] |
| pub const fn empty() -> Self { |
| Self(0) |
| } |
| |
| #[deprecated(since = "0.31.0", note = "Use `empty` instead.")] |
| #[doc = concat!("Returns a `", stringify!($ty), "` with none of the flags set.")] |
| #[inline] |
| pub const fn none() -> Self { |
| Self::empty() |
| } |
| |
| const fn all_raw() -> $repr { |
| 0 |
| $( |
| | ash::vk::$ty_ffi::$flag_name_ffi.as_raw() |
| )* |
| } |
| |
| /// Returns the number of flags set in self. |
| #[inline] |
| pub const fn count(self) -> u32 { |
| self.0.count_ones() |
| } |
| |
| /// Returns whether no flags are set in `self`. |
| #[inline] |
| pub const fn is_empty(self) -> bool { |
| self.0 == 0 |
| } |
| |
| /// Returns whether any flags are set in both `self` and `other`. |
| #[inline] |
| pub const fn intersects(self, #[allow(unused_variables)] other: Self) -> bool { |
| self.0 & other.0 != 0 |
| } |
| |
| /// Returns whether all flags in `other` are set in `self`. |
| #[inline] |
| pub const fn contains(self, #[allow(unused_variables)] other: Self) -> bool { |
| self.0 & other.0 == other.0 |
| } |
| |
| /// Returns the union of `self` and `other`. |
| #[inline] |
| pub const fn union(self, #[allow(unused_variables)] other: Self) -> Self { |
| Self(self.0 | other.0) |
| } |
| |
| /// Returns the intersection of `self` and `other`. |
| #[inline] |
| pub const fn intersection(self, #[allow(unused_variables)] other: Self) -> Self { |
| Self(self.0 & other.0) |
| } |
| |
| /// Returns `self` without the flags set in `other`. |
| #[inline] |
| pub const fn difference(self, #[allow(unused_variables)] other: Self) -> Self { |
| Self(self.0 & !other.0) |
| } |
| |
| /// Returns the flags that are set in `self` or `other`, but not in both. |
| #[inline] |
| pub const fn symmetric_difference(self, #[allow(unused_variables)] other: Self) -> Self { |
| Self(self.0 ^ other.0) |
| } |
| |
| #[allow(dead_code)] |
| pub(crate) fn validate_device( |
| self, |
| #[allow(unused_variables)] device: &crate::device::Device, |
| ) -> Result<(), crate::RequirementNotMet> { |
| $( |
| $( |
| if self.intersects(Self::$flag_name) && ![ |
| $( |
| device.api_version() >= crate::Version::$api_version, |
| )? |
| $($( |
| device.enabled_features().$feature, |
| )+)? |
| $($( |
| device.enabled_extensions().$device_extension, |
| )+)? |
| $($( |
| device.instance().enabled_extensions().$instance_extension, |
| )+)? |
| ].into_iter().any(|x| x) { |
| return Err(crate::RequirementNotMet { |
| required_for: concat!("`", stringify!($ty), "::", stringify!($flag_name), "`"), |
| requires_one_of: crate::RequiresOneOf { |
| $(api_version: Some(crate::Version::$api_version),)? |
| $(features: &[$(stringify!($feature)),+],)? |
| $(device_extensions: &[$(stringify!($device_extension)),+],)? |
| $(instance_extensions: &[$(stringify!($instance_extension)),+],)? |
| ..Default::default() |
| }, |
| }); |
| } |
| )? |
| )* |
| |
| Ok(()) |
| } |
| |
| #[allow(dead_code)] |
| pub(crate) fn validate_physical_device( |
| self, |
| #[allow(unused_variables)] physical_device: &crate::device::physical::PhysicalDevice, |
| ) -> Result<(), crate::RequirementNotMet> { |
| $( |
| $( |
| if self.intersects(Self::$flag_name) && ![ |
| $( |
| physical_device.api_version() >= crate::Version::$api_version, |
| )? |
| $($( |
| physical_device.supported_features().$feature, |
| )+)? |
| $($( |
| physical_device.supported_extensions().$device_extension, |
| )+)? |
| $($( |
| physical_device.instance().enabled_extensions().$instance_extension, |
| )+)? |
| ].into_iter().any(|x| x) { |
| return Err(crate::RequirementNotMet { |
| required_for: concat!("`", stringify!($ty), "::", stringify!($flag_name), "`"), |
| requires_one_of: crate::RequiresOneOf { |
| $(api_version: Some(crate::Version::$api_version),)? |
| $(features: &[$(stringify!($feature)),+],)? |
| $(device_extensions: &[$(stringify!($device_extension)),+],)? |
| $(instance_extensions: &[$(stringify!($instance_extension)),+],)? |
| ..Default::default() |
| }, |
| }); |
| } |
| )? |
| )* |
| |
| Ok(()) |
| } |
| |
| #[allow(dead_code)] |
| pub(crate) fn validate_instance( |
| self, |
| #[allow(unused_variables)] instance: &crate::instance::Instance, |
| ) -> Result<(), crate::RequirementNotMet> { |
| $( |
| $( |
| if self.intersects(Self::$flag_name) && ![ |
| $( |
| instance.api_version() >= crate::Version::$api_version, |
| )? |
| $($( |
| instance.enabled_extensions().$instance_extension, |
| )+)? |
| ].into_iter().any(|x| x) { |
| return Err(crate::RequirementNotMet { |
| required_for: concat!("`", stringify!($ty), "::", stringify!($flag_name), "`"), |
| requires_one_of: crate::RequiresOneOf { |
| $(api_version: Some(crate::Version::$api_version),)? |
| $(instance_extensions: &[$(stringify!($instance_extension)),+],)? |
| ..Default::default() |
| }, |
| }); |
| } |
| )? |
| )* |
| |
| Ok(()) |
| } |
| |
| $( $($impls)* )? |
| } |
| |
| impl Default for $ty { |
| #[inline] |
| fn default() -> Self { |
| Self::empty() |
| } |
| } |
| |
| impl std::fmt::Debug for $ty { |
| fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> { |
| #[allow(unused_mut)] |
| let mut written = false; |
| |
| $( |
| if self.intersects(Self::$flag_name) { |
| if written { |
| write!(f, " | ")?; |
| } |
| |
| write!(f, stringify!($flag_name))?; |
| written = true; |
| } |
| )* |
| |
| if !written { |
| write!(f, "empty()")?; |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| impl From<$ty> for ash::vk::$ty_ffi { |
| #[inline] |
| fn from(val: $ty) -> Self { |
| ash::vk::$ty_ffi::from_raw(val.0) |
| } |
| } |
| |
| impl From<ash::vk::$ty_ffi> for $ty { |
| #[inline] |
| fn from(val: ash::vk::$ty_ffi) -> Self { |
| Self(val.as_raw() & Self::all_raw()) |
| } |
| } |
| |
| impl std::ops::BitAnd for $ty { |
| type Output = Self; |
| |
| #[inline] |
| fn bitand(self, rhs: Self) -> Self { |
| self.intersection(rhs) |
| } |
| } |
| |
| impl std::ops::BitAndAssign for $ty { |
| #[inline] |
| fn bitand_assign(&mut self, rhs: Self) { |
| *self = self.intersection(rhs); |
| } |
| } |
| |
| impl std::ops::BitOr for $ty { |
| type Output = Self; |
| |
| #[inline] |
| fn bitor(self, rhs: Self) -> Self { |
| self.union(rhs) |
| } |
| } |
| |
| impl std::ops::BitOrAssign for $ty { |
| #[inline] |
| fn bitor_assign(&mut self, rhs: Self) { |
| *self = self.union(rhs); |
| } |
| } |
| |
| impl std::ops::BitXor for $ty { |
| type Output = Self; |
| |
| #[inline] |
| fn bitxor(self, rhs: Self) -> Self { |
| self.symmetric_difference(rhs) |
| } |
| } |
| |
| impl std::ops::BitXorAssign for $ty { |
| #[inline] |
| fn bitxor_assign(&mut self, rhs: Self) { |
| *self = self.symmetric_difference(rhs); |
| } |
| } |
| |
| impl std::ops::Sub for $ty { |
| type Output = Self; |
| |
| #[inline] |
| fn sub(self, rhs: Self) -> Self { |
| self.difference(rhs) |
| } |
| } |
| |
| impl std::ops::SubAssign for $ty { |
| #[inline] |
| fn sub_assign(&mut self, rhs: Self) { |
| *self = self.difference(rhs); |
| } |
| } |
| }; |
| } |
| |
| macro_rules! vulkan_enum { |
| { |
| $(#[doc = $ty_doc:literal])* |
| $ty:ident |
| $( impl { $($impls:item)* } )? |
| = $ty_ffi:ident($repr:ty); |
| |
| $( |
| $(#[doc = $flag_doc:literal])* |
| $flag_name:ident = $flag_name_ffi:ident, |
| )+ |
| } => { |
| $(#[doc = $ty_doc])* |
| #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] |
| #[repr($repr)] |
| pub enum $ty { |
| $( |
| $(#[doc = $flag_doc])* |
| $flag_name = ash::vk::$ty_ffi::$flag_name_ffi.as_raw(), |
| )+ |
| } |
| |
| $( |
| impl $ty { |
| $($impls)* |
| } |
| )? |
| |
| impl From<$ty> for ash::vk::$ty_ffi { |
| #[inline] |
| fn from(val: $ty) -> Self { |
| ash::vk::$ty_ffi::from_raw(val as $repr) |
| } |
| } |
| |
| impl TryFrom<ash::vk::$ty_ffi> for $ty { |
| type Error = (); |
| |
| #[inline] |
| fn try_from(val: ash::vk::$ty_ffi) -> Result<Self, Self::Error> { |
| Ok(match val { |
| $( |
| ash::vk::$ty_ffi::$flag_name_ffi => Self::$flag_name, |
| )+ |
| _ => return Err(()), |
| }) |
| } |
| } |
| }; |
| |
| { |
| #[non_exhaustive] |
| |
| $(#[doc = $ty_doc:literal])* |
| $ty:ident |
| $( impl { $($impls:item)* } )? |
| = $ty_ffi:ident($repr:ty); |
| |
| $( |
| $(#[doc = $flag_doc:literal])* |
| $flag_name:ident = $flag_name_ffi:ident |
| $({ |
| $(api_version: $api_version:ident,)? |
| $(features: [$($feature:ident),+ $(,)?],)? |
| $(device_extensions: [$($device_extension:ident),+ $(,)?],)? |
| $(instance_extensions: [$($instance_extension:ident),+ $(,)?],)? |
| })? |
| , |
| )+ |
| } => { |
| $(#[doc = $ty_doc])* |
| #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] |
| #[non_exhaustive] |
| #[repr($repr)] |
| pub enum $ty { |
| $( |
| $(#[doc = $flag_doc])* |
| $flag_name = ash::vk::$ty_ffi::$flag_name_ffi.as_raw(), |
| )+ |
| } |
| |
| impl $ty { |
| #[allow(dead_code)] |
| pub(crate) fn validate_device( |
| self, |
| #[allow(unused_variables)] device: &crate::device::Device, |
| ) -> Result<(), crate::RequirementNotMet> { |
| match self { |
| $( |
| $( |
| Self::$flag_name => { |
| if ![ |
| $( |
| device.api_version() >= crate::Version::$api_version, |
| )? |
| $($( |
| device.enabled_features().$feature, |
| )+)? |
| $($( |
| device.enabled_extensions().$device_extension, |
| )+)? |
| $($( |
| device.instance().enabled_extensions().$instance_extension, |
| )+)? |
| ].into_iter().any(|x| x) { |
| return Err(crate::RequirementNotMet { |
| required_for: concat!("`", stringify!($ty), "::", stringify!($flag_name), "`"), |
| requires_one_of: crate::RequiresOneOf { |
| $(api_version: Some(crate::Version::$api_version),)? |
| $(features: &[$(stringify!($feature)),+],)? |
| $(device_extensions: &[$(stringify!($device_extension)),+],)? |
| $(instance_extensions: &[$(stringify!($instance_extension)),+],)? |
| ..Default::default() |
| }, |
| }); |
| } |
| }, |
| )? |
| )+ |
| _ => (), |
| } |
| |
| Ok(()) |
| } |
| |
| #[allow(dead_code)] |
| pub(crate) fn validate_physical_device( |
| self, |
| #[allow(unused_variables)] physical_device: &crate::device::physical::PhysicalDevice, |
| ) -> Result<(), crate::RequirementNotMet> { |
| match self { |
| $( |
| $( |
| Self::$flag_name => { |
| if ![ |
| $( |
| physical_device.api_version() >= crate::Version::$api_version, |
| )? |
| $($( |
| physical_device.supported_features().$feature, |
| )+)? |
| $($( |
| physical_device.supported_extensions().$device_extension, |
| )+)? |
| $($( |
| physical_device.instance().enabled_extensions().$instance_extension, |
| )+)? |
| ].into_iter().any(|x| x) { |
| return Err(crate::RequirementNotMet { |
| required_for: concat!("`", stringify!($ty), "::", stringify!($flag_name), "`"), |
| requires_one_of: crate::RequiresOneOf { |
| $(api_version: Some(crate::Version::$api_version),)? |
| $(features: &[$(stringify!($feature)),+],)? |
| $(device_extensions: &[$(stringify!($device_extension)),+],)? |
| $(instance_extensions: &[$(stringify!($instance_extension)),+],)? |
| ..Default::default() |
| }, |
| }); |
| } |
| }, |
| )? |
| )+ |
| _ => (), |
| } |
| |
| Ok(()) |
| } |
| |
| #[allow(dead_code)] |
| pub(crate) fn validate_instance( |
| self, |
| #[allow(unused_variables)] instance: &crate::instance::Instance, |
| ) -> Result<(), crate::RequirementNotMet> { |
| match self { |
| $( |
| $( |
| Self::$flag_name => { |
| if ![ |
| $( |
| instance.api_version() >= crate::Version::$api_version, |
| )? |
| $($( |
| instance.enabled_extensions().$instance_extension, |
| )+)? |
| ].into_iter().any(|x| x) { |
| return Err(crate::RequirementNotMet { |
| required_for: concat!("`", stringify!($ty), "::", stringify!($flag_name), "`"), |
| requires_one_of: crate::RequiresOneOf { |
| $(api_version: Some(crate::Version::$api_version),)? |
| $(instance_extensions: &[$(stringify!($instance_extension)),+],)? |
| ..Default::default() |
| }, |
| }); |
| } |
| }, |
| )? |
| )+ |
| _ => (), |
| } |
| |
| Ok(()) |
| } |
| |
| $( |
| $($impls)* |
| )? |
| } |
| |
| impl From<$ty> for ash::vk::$ty_ffi { |
| #[inline] |
| fn from(val: $ty) -> Self { |
| ash::vk::$ty_ffi::from_raw(val as $repr) |
| } |
| } |
| |
| impl TryFrom<ash::vk::$ty_ffi> for $ty { |
| type Error = (); |
| |
| #[inline] |
| fn try_from(val: ash::vk::$ty_ffi) -> Result<Self, Self::Error> { |
| Ok(match val { |
| $( |
| ash::vk::$ty_ffi::$flag_name_ffi => Self::$flag_name, |
| )+ |
| _ => return Err(()), |
| }) |
| } |
| } |
| }; |
| } |
| |
| macro_rules! vulkan_bitflags_enum { |
| { |
| #[non_exhaustive] |
| |
| $(#[doc = $ty_bitflags_doc:literal])* |
| $ty_bitflags:ident |
| $( impl { $($impls_bitflags:item)* } )? |
| , |
| |
| $(#[doc = $ty_enum_doc:literal])* |
| $ty_enum:ident |
| $( impl { $($impls_enum:item)* } )? |
| , |
| |
| = $ty_ffi:ident($repr:ty); |
| |
| $( |
| $(#[doc = $flag_doc:literal])* |
| $flag_name_bitflags:ident, $flag_name_enum:ident = $flag_name_ffi:ident |
| $({ |
| $(api_version: $api_version:ident,)? |
| $(features: [$($feature:ident),+ $(,)?],)? |
| $(device_extensions: [$($device_extension:ident),+ $(,)?],)? |
| $(instance_extensions: [$($instance_extension:ident),+ $(,)?],)? |
| })? |
| , |
| )* |
| } => { |
| crate::macros::vulkan_bitflags! { |
| #[non_exhaustive] |
| |
| $(#[doc = $ty_bitflags_doc])* |
| $ty_bitflags |
| impl { |
| /// Returns whether `self` contains the flag corresponding to `val`. |
| #[inline] |
| pub fn contains_enum(self, val: $ty_enum) -> bool { |
| self.intersects(val.into()) |
| } |
| |
| $( $($impls_bitflags)* )? |
| } |
| = $ty_ffi($repr); |
| |
| $( |
| $(#[doc = $flag_doc])* |
| $flag_name_bitflags = $flag_name_ffi |
| $({ |
| $(api_version: $api_version,)? |
| $(features: [$($feature),+],)? |
| $(device_extensions: [$($device_extension),+],)? |
| $(instance_extensions: [$($instance_extension),+],)? |
| })? |
| , |
| )* |
| } |
| |
| crate::macros::vulkan_enum! { |
| #[non_exhaustive] |
| |
| $(#[doc = $ty_enum_doc])* |
| $ty_enum |
| $( impl { $($impls_enum)* } )? |
| = $ty_ffi($repr); |
| |
| $( |
| $(#[doc = $flag_doc])* |
| $flag_name_enum = $flag_name_ffi |
| $({ |
| $(api_version: $api_version,)? |
| $(features: [$($feature),+],)? |
| $(device_extensions: [$($device_extension),+],)? |
| $(instance_extensions: [$($instance_extension),+],)? |
| })? |
| , |
| )* |
| } |
| |
| impl From<$ty_enum> for $ty_bitflags { |
| #[inline] |
| fn from(val: $ty_enum) -> Self { |
| Self(val as $repr) |
| } |
| } |
| |
| impl FromIterator<$ty_enum> for $ty_bitflags { |
| #[inline] |
| fn from_iter<T>(iter: T) -> Self where T: IntoIterator<Item = $ty_enum> { |
| iter.into_iter().map(|item| Self::from(item)).fold(Self::empty(), |r, i| r.union(i)) |
| } |
| } |
| |
| impl IntoIterator for $ty_bitflags { |
| type Item = $ty_enum; |
| type IntoIter = std::iter::Flatten< |
| std::array::IntoIter< |
| Option<Self::Item>, |
| { $ty_bitflags::all_raw().count_ones() as usize }, |
| > |
| >; |
| |
| #[inline] |
| fn into_iter(self) -> Self::IntoIter { |
| [ |
| $( |
| self.intersects(Self::$flag_name_bitflags) |
| .then_some($ty_enum::$flag_name_enum), |
| )* |
| ].into_iter().flatten() |
| } |
| } |
| } |
| } |
| |
| macro_rules! impl_id_counter { |
| ($type:ident $(< $($param:ident $(: $bound:ident $(+ $bounds:ident)* )?),+ >)?) => { |
| $crate::macros::impl_id_counter!( |
| @inner $type $(< $($param),+ >)?, $( $($param $(: $bound $(+ $bounds)* )?),+)? |
| ); |
| }; |
| ($type:ident $(< $($param:ident $(: $bound:ident $(+ $bounds:ident)* )? + ?Sized),+ >)?) => { |
| $crate::macros::impl_id_counter!( |
| @inner $type $(< $($param),+ >)?, $( $($param $(: $bound $(+ $bounds)* )? + ?Sized),+)? |
| ); |
| }; |
| (@inner $type:ident $(< $($param:ident),+ >)?, $($bounds:tt)*) => { |
| impl< $($bounds)* > $type $(< $($param),+ >)? { |
| fn next_id() -> std::num::NonZeroU64 { |
| use std::{ |
| num::NonZeroU64, |
| sync::atomic::{AtomicU64, Ordering}, |
| }; |
| |
| static COUNTER: AtomicU64 = AtomicU64::new(1); |
| |
| NonZeroU64::new(COUNTER.fetch_add(1, Ordering::Relaxed)).unwrap_or_else(|| { |
| println!("an ID counter has overflown ...somehow"); |
| std::process::abort(); |
| }) |
| } |
| } |
| |
| impl< $($bounds)* > PartialEq for $type $(< $($param),+ >)? { |
| #[inline] |
| fn eq(&self, other: &Self) -> bool { |
| self.id == other.id |
| } |
| } |
| |
| impl< $($bounds)* > Eq for $type $(< $($param),+ >)? {} |
| |
| impl< $($bounds)* > std::hash::Hash for $type $(< $($param),+ >)? { |
| fn hash<H: std::hash::Hasher>(&self, state: &mut H) { |
| self.id.hash(state); |
| } |
| } |
| }; |
| } |
| |
| // TODO: Replace with the `?` operator once its constness is stabilized. |
| macro_rules! try_opt { |
| ($e:expr) => { |
| if let Some(val) = $e { |
| val |
| } else { |
| return None; |
| } |
| }; |
| } |
| |
| pub(crate) use {impl_id_counter, try_opt, vulkan_bitflags, vulkan_bitflags_enum, vulkan_enum}; |
