diff options
Diffstat (limited to 'src/bool/wasm32/bvec3a.rs')
| -rw-r--r-- | src/bool/wasm32/bvec3a.rs | 199 |
1 files changed, 199 insertions, 0 deletions
diff --git a/src/bool/wasm32/bvec3a.rs b/src/bool/wasm32/bvec3a.rs new file mode 100644 index 0000000..755246a --- /dev/null +++ b/src/bool/wasm32/bvec3a.rs @@ -0,0 +1,199 @@ +// Generated from vec_mask.rs.tera template. Edit the template, not the generated file. + +#[cfg(not(target_arch = "spirv"))] +use core::fmt; +use core::ops::*; + +use core::arch::wasm32::*; + +/// A 3-dimensional SIMD vector mask. +/// +/// This type is 16 byte aligned and is backed by a SIMD vector. If SIMD is not available +/// `BVec3A` will be a type alias for `BVec3`. +#[derive(Clone, Copy)] +#[repr(transparent)] +pub struct BVec3A(pub(crate) v128); + +const MASK: [u32; 2] = [0, 0xff_ff_ff_ff]; + +impl BVec3A { + /// All false. + pub const FALSE: Self = Self::splat(false); + + /// All true. + pub const TRUE: Self = Self::splat(true); + + /// Creates a new vector mask. + #[inline(always)] + pub const fn new(x: bool, y: bool, z: bool) -> Self { + Self(u32x4( + MASK[x as usize], + MASK[y as usize], + MASK[z as usize], + 0, + )) + } + + /// Creates a vector with all elements set to `v`. + #[inline] + pub const fn splat(v: bool) -> Self { + Self::new(v, v, v) + } + + /// Returns a bitmask with the lowest 3 bits set from the elements of `self`. + /// + /// A true element results in a `1` bit and a false element in a `0` bit. Element `x` goes + /// into the first lowest bit, element `y` into the second, etc. + #[inline] + pub fn bitmask(self) -> u32 { + (u32x4_bitmask(self.0) & 0x7) as u32 + } + + /// Returns true if any of the elements are true, false otherwise. + #[inline] + pub fn any(self) -> bool { + self.bitmask() != 0 + } + + /// Returns true if all the elements are true, false otherwise. + #[inline] + pub fn all(self) -> bool { + self.bitmask() == 0x7 + } + + #[inline] + fn into_bool_array(self) -> [bool; 3] { + let bitmask = self.bitmask(); + [(bitmask & 1) != 0, (bitmask & 2) != 0, (bitmask & 4) != 0] + } + + #[inline] + fn into_u32_array(self) -> [u32; 3] { + let bitmask = self.bitmask(); + [ + MASK[(bitmask & 1) as usize], + MASK[((bitmask >> 1) & 1) as usize], + MASK[((bitmask >> 2) & 1) as usize], + ] + } +} + +impl Default for BVec3A { + #[inline] + fn default() -> Self { + Self::FALSE + } +} + +impl PartialEq for BVec3A { + #[inline] + fn eq(&self, rhs: &Self) -> bool { + self.bitmask().eq(&rhs.bitmask()) + } +} + +impl Eq for BVec3A {} + +impl core::hash::Hash for BVec3A { + #[inline] + fn hash<H: core::hash::Hasher>(&self, state: &mut H) { + self.bitmask().hash(state); + } +} + +impl BitAnd for BVec3A { + type Output = Self; + #[inline] + fn bitand(self, rhs: Self) -> Self { + Self(v128_and(self.0, rhs.0)) + } +} + +impl BitAndAssign for BVec3A { + #[inline] + fn bitand_assign(&mut self, rhs: Self) { + *self = self.bitand(rhs); + } +} + +impl BitOr for BVec3A { + type Output = Self; + #[inline] + fn bitor(self, rhs: Self) -> Self { + Self(v128_or(self.0, rhs.0)) + } +} + +impl BitOrAssign for BVec3A { + #[inline] + fn bitor_assign(&mut self, rhs: Self) { + *self = self.bitor(rhs); + } +} + +impl BitXor for BVec3A { + type Output = Self; + #[inline] + fn bitxor(self, rhs: Self) -> Self { + Self(v128_xor(self.0, rhs.0)) + } +} + +impl BitXorAssign for BVec3A { + #[inline] + fn bitxor_assign(&mut self, rhs: Self) { + *self = self.bitxor(rhs); + } +} + +impl Not for BVec3A { + type Output = Self; + #[inline] + fn not(self) -> Self { + Self(v128_not(self.0)) + } +} + +impl From<BVec3A> for v128 { + #[inline] + fn from(t: BVec3A) -> Self { + t.0 + } +} + +#[cfg(not(target_arch = "spirv"))] +impl fmt::Debug for BVec3A { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let arr = self.into_u32_array(); + write!( + f, + "{}({:#x}, {:#x}, {:#x})", + stringify!(BVec3A), + arr[0], + arr[1], + arr[2] + ) + } +} + +#[cfg(not(target_arch = "spirv"))] +impl fmt::Display for BVec3A { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let arr = self.into_bool_array(); + write!(f, "[{}, {}, {}]", arr[0], arr[1], arr[2]) + } +} + +impl From<BVec3A> for [bool; 3] { + #[inline] + fn from(mask: BVec3A) -> Self { + mask.into_bool_array() + } +} + +impl From<BVec3A> for [u32; 3] { + #[inline] + fn from(mask: BVec3A) -> Self { + mask.into_u32_array() + } +} |