Add Asin, Atan2, Dot, Length, Normalize, Round, Step traits

Author: ProfLander

src/asin.rs

@@ -0,0 +1,43 @@
+//! WGSL `asin()`
+
+use crate::glam::{Vec2, Vec3, Vec4};
+
+/// Equivalent of the WGSL `saturate()` function.
+///
+/// Clamps a value to the 0.0..=1.0 range
+pub trait Asin {
+    fn asin(self) -> Self;
+}
+
+impl Asin for f32 {
+    fn asin(self) -> Self {
+        #[cfg(feature = "glam")]
+        {
+            f32::asin(self)
+        }
+
+        #[cfg(feature = "spirv-std")]
+        {
+            spirv_std::num_traits::Float::asin(self)
+        }
+    }
+}
+
+impl Asin for Vec2 {
+    fn asin(self) -> Self {
+        Vec2::new(self.x.asin(), self.y.asin())
+    }
+}
+
+impl Asin for Vec3 {
+    fn asin(self) -> Self {
+        Vec3::new(self.x.asin(), self.y.asin(), self.z.asin())
+    }
+}
+
+impl Asin for Vec4 {
+    fn asin(self) -> Self {
+        Vec4::new(self.x.asin(), self.y.asin(), self.z.asin(), self.w.asin())
+    }
+}
+

src/atan2.rs

@@ -0,0 +1,53 @@
+//! WGSL `atan2()`
+
+use crate::glam::{Vec2, Vec3, Vec4};
+
+#[cfg(feature = "spirv-std")]
+#[allow(unused_imports)]
+use spirv_std::num_traits::Float;
+
+/// Equivalent of the WGSL `atan2()` function.
+pub trait Atan2 {
+    fn atan2(self, p: Self) -> Self;
+}
+
+impl Atan2 for f32 {
+    fn atan2(self, p: Self) -> Self {
+        #[cfg(feature = "glam")]
+        {
+            f32::atan2(self, p)
+        }
+
+        #[cfg(feature = "spirv-std")]
+        {
+            <f32 as spirv_std::num_traits::Float>::atan2(self, p)
+        }
+    }
+}
+
+impl Atan2 for Vec2 {
+    fn atan2(self, p: Self) -> Self {
+        Vec2::new(Atan2::atan2(self.x, p.x), Atan2::atan2(self.y, p.y))
+    }
+}
+
+impl Atan2 for Vec3 {
+    fn atan2(self, p: Self) -> Self {
+        Vec3::new(
+            Atan2::atan2(self.x, p.x),
+            Atan2::atan2(self.y, p.y),
+            Atan2::atan2(self.z, p.z),
+        )
+    }
+}
+
+impl Atan2 for Vec4 {
+    fn atan2(self, p: Self) -> Self {
+        Vec4::new(
+            Atan2::atan2(self.x, p.x),
+            Atan2::atan2(self.y, p.y),
+            Atan2::atan2(self.z, p.z),
+            Atan2::atan2(self.w, p.w),
+        )
+    }
+}

src/dot.rs

@@ -0,0 +1,39 @@
+//! WGSL `dot()`
+
+use crate::glam::{Vec2, Vec3, Vec4};
+
+#[cfg(feature = "spirv-std")]
+#[allow(unused_imports)]
+use spirv_std::num_traits::Float;
+
+/// Equivalent of the WGSL `dot()` function.
+///
+/// Returns a scalar from -1.0..1.0 denoting the similarity of two vectors.
+pub trait Dot {
+    fn dot(self, rhs: Self) -> f32;
+}
+
+impl Dot for f32 {
+    fn dot(self, rhs: Self) -> f32 {
+        self * rhs
+    }
+}
+
+impl Dot for Vec2 {
+    fn dot(self, rhs: Self) -> f32 {
+        Vec2::dot(self, rhs)
+    }
+}
+
+impl Dot for Vec3 {
+    fn dot(self, rhs: Self) -> f32 {
+        Vec3::dot(self, rhs)
+    }
+}
+
+impl Dot for Vec4 {
+    fn dot(self, rhs: Self) -> f32 {
+        Vec4::dot(self, rhs)
+    }
+}
+

src/length.rs

@@ -0,0 +1,47 @@
+//! WGSL `length()`
+
+use crate::glam::{Vec2, Vec3, Vec4};
+
+#[cfg(feature = "spirv-std")]
+#[allow(unused_imports)]
+use spirv_std::num_traits::Float;
+
+/// Equivalent of the WGSL `length()` function.
+///
+/// Returns the length of self.
+pub trait Length {
+    fn length(self) -> f32;
+}
+
+impl Length for f32 {
+    fn length(self) -> f32 {
+        #[cfg(feature = "glam")]
+        {
+            f32::abs(self)
+        }
+
+        #[cfg(feature = "spirv-std")]
+        {
+            spirv_std::num_traits::Float::abs(self)
+        }
+    }
+}
+
+impl Length for Vec2 {
+    fn length(self) -> f32 {
+        Vec2::length(self)
+    }
+}
+
+impl Length for Vec3 {
+    fn length(self) -> f32 {
+        Vec3::length(self)
+    }
+}
+
+impl Length for Vec4 {
+    fn length(self) -> f32 {
+        Vec4::length(self)
+    }
+}
+

src/lib.rs

@@ -16,22 +16,29 @@ pub use spirv_std::glam;
 #[cfg(all(not(feature = "glam"), not(feature = "spirv-std")))]
 compile_error!("Either the glam or spirv-std feature must be enabled.");
 
-pub mod acos;
 pub mod abs;
+pub mod asin;
+pub mod acos;
+pub mod atan2;
 pub mod clamp;
 pub mod cos;
+pub mod dot;
 pub mod exp2;
+pub mod length;
 pub mod log2;
 pub mod mix;
 pub mod modulo;
 pub mod natural_log;
+pub mod normalize;
 pub mod pow;
 pub mod reflect;
+pub mod round;
 pub mod saturate;
 pub mod sign;
 pub mod sin;
 pub mod smooth_step;
 pub mod sqrt;
+pub mod step;
 pub mod tan;
 
 pub mod prelude;

src/normalize.rs

@@ -0,0 +1,42 @@
+//! WGSL `normalize()`
+
+use crate::{
+    glam::{Vec2, Vec3, Vec4},
+    sign::Sign,
+};
+
+#[cfg(feature = "spirv-std")]
+#[allow(unused_imports)]
+use spirv_std::num_traits::Float;
+
+/// Equivalent of the WGSL `normalize()` function.
+///
+/// Returns the provided vector quantity scaled such that its length is 1.
+pub trait Normalize {
+    fn normalize(self) -> Self;
+}
+
+impl Normalize for f32 {
+    fn normalize(self) -> Self {
+        self.sign()
+    }
+}
+
+impl Normalize for Vec2 {
+    fn normalize(self) -> Self {
+        Vec2::normalize(self)
+    }
+}
+
+impl Normalize for Vec3 {
+    fn normalize(self) -> Self {
+        Vec3::normalize(self)
+    }
+}
+
+impl Normalize for Vec4 {
+    fn normalize(self) -> Self {
+        Vec4::normalize(self)
+    }
+}
+

src/prelude.rs

@@ -1,5 +1,5 @@
 pub use crate::{
-    abs::*, acos::*, clamp::*, cos::*, exp2::*, glam::*, log2::*, mix::*, modulo::*,
-    natural_log::*, pow::*, reflect::*, saturate::*, sign::*, sin::*, smooth_step::*, sqrt::*,
-    tan::*, *,
+    abs::*, acos::*, asin::*, atan2::*, clamp::*, cos::*, dot::*, exp2::*, glam::*, length::*,
+    log2::*, mix::*, modulo::*, natural_log::*, normalize::*, pow::*, reflect::*, round::*,
+    saturate::*, sign::*, sin::*, smooth_step::*, sqrt::*, step::*, tan::*, *,
 };

src/round.rs

@@ -0,0 +1,52 @@
+//! WGSL `round()`
+
+use crate::glam::{Vec2, Vec3, Vec4};
+
+#[cfg(feature = "spirv-std")]
+#[allow(unused_imports)]
+use spirv_std::num_traits::Float;
+
+/// Equivalent of the WGSL `round()` function.
+///
+/// Returns self rounded to the nearest integer.
+pub trait Round {
+    fn round(self) -> Self;
+}
+
+impl Round for f32 {
+    fn round(self) -> Self {
+        #[cfg(feature = "glam")]
+        {
+            f32::round(self)
+        }
+
+        #[cfg(feature = "spirv-std")]
+        {
+            spirv_std::num_traits::Float::round(self)
+        }
+    }
+}
+
+impl Round for Vec2 {
+    fn round(self) -> Self {
+        Vec2::new(Round::round(self.x), Round::round(self.y))
+    }
+}
+
+impl Round for Vec3 {
+    fn round(self) -> Self {
+        Vec3::new(Round::round(self.x), Round::round(self.y), Round::round(self.z))
+    }
+}
+
+impl Round for Vec4 {
+    fn round(self) -> Self {
+        Vec4::new(
+            Round::round(self.x),
+            Round::round(self.y),
+            Round::round(self.z),
+            Round::round(self.w),
+        )
+    }
+}
+

src/step.rs

@@ -0,0 +1,44 @@
+//! WGSL `step()`
+
+use crate::glam::{Vec2, Vec3, Vec4};
+
+/// Equivalent of the WGSL `step()` function.
+///
+/// Returns 1.0 if value is >= edge, 0.0 otherwise
+pub trait Step {
+    fn step(self, edge: f32) -> Self;
+}
+
+impl Step for f32 {
+    fn step(self, edge: f32) -> Self {
+        if edge >= self {
+            1.0
+        } else {
+            0.0
+        }
+    }
+}
+
+impl Step for Vec2 {
+    fn step(self, edge: f32) -> Self {
+        Vec2::new(self.x.step(edge), self.y.step(edge))
+    }
+}
+
+impl Step for Vec3 {
+    fn step(self, edge: f32) -> Self {
+        Vec3::new(self.x.step(edge), self.y.step(edge), self.z.step(edge))
+    }
+}
+
+impl Step for Vec4 {
+    fn step(self, edge: f32) -> Self {
+        Vec4::new(
+            self.x.step(edge),
+            self.y.step(edge),
+            self.z.step(edge),
+            self.w.step(edge),
+        )
+    }
+}
+