scalar or vector: move all scalar traits and impl macros to mod scalar

Author: Firestar99

crates/spirv-std/src/float.rs

@@ -4,24 +4,6 @@
 use core::arch::asm;
 use glam::{Vec2, Vec4};
 
-/// Abstract trait representing a SPIR-V floating point type.
-///
-/// # Safety
-/// Implementing this trait on non-primitive-float types breaks assumptions of other unsafe code,
-/// and should not be done.
-pub unsafe trait Float: num_traits::Float + crate::scalar::Scalar + Default {
-    /// Width of the float, in bits.
-    const WIDTH: usize;
-}
-
-unsafe impl Float for f32 {
-    const WIDTH: usize = 32;
-}
-
-unsafe impl Float for f64 {
-    const WIDTH: usize = 64;
-}
-
 /// Converts two f32 values (floats) into two f16 values (halfs). The result is a u32, with the low
 /// 16 bits being the first f16, and the high 16 bits being the second f16.
 #[spirv_std_macros::gpu_only]

crates/spirv-std/src/integer.rs

@@ -94,10 +94,8 @@ pub mod byte_addressable_buffer;
 pub mod float;
 pub mod image;
 pub mod indirect_command;
-mod integer;
 pub mod matrix;
 pub mod memory;
-mod number;
 pub mod ray_tracing;
 mod runtime_array;
 mod sampler;
@@ -109,10 +107,7 @@ mod vector;
 pub use self::sampler::Sampler;
 pub use crate::macros::Image;
 pub use byte_addressable_buffer::ByteAddressableBuffer;
-pub use float::Float;
-pub use integer::*;
 pub use num_traits;
-pub use number::*;
 pub use runtime_array::*;
 pub use scalar::*;
 pub use typed_buffer::*;

crates/spirv-std/src/lib.rs

@@ -1,31 +1,113 @@
 //! Traits related to scalars.
 
-use crate::vector::VectorOrScalar;
+use crate::VectorOrScalar;
+use crate::sealed::Sealed;
 use core::num::NonZeroUsize;
 
-/// Abstract trait representing a SPIR-V scalar type.
-///
-/// Implemented on types that map to spirv "scalar" types, which includes:
+/// Abstract trait representing a SPIR-V scalar type, which includes:
 /// * Floating-point type: f32, f64
 /// * Integer type: u8, u16, u32, u64, i8, i16, i32, i64
 /// * Boolean type: bool
 ///
 /// See the SPIRV spec on [Types](https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#_types).
 ///
 /// # Safety
-/// Must only be implemented on spirv "scalar" types, as mentioned above.
+/// Implementing this trait on non-scalar types breaks assumptions of other unsafe code, and should not be done.
 pub unsafe trait Scalar: VectorOrScalar<Scalar = Self> + crate::sealed::Sealed {}
 
+/// Abstract trait representing a SPIR-V integer or floating-point type. Unlike [`Scalar`], excludes the boolean type.
+///
+/// # Safety
+/// Implementing this trait on non-primitive-integer or non-primitive-float types breaks assumptions of other unsafe
+/// code, and should not be done.
+pub unsafe trait Number: Scalar {}
+
+/// Abstract trait representing any SPIR-V integer type.
+///
+/// # Safety
+/// Implementing this trait on non-primitive-integer types breaks assumptions of other unsafe code,
+/// and should not be done.
+pub unsafe trait Integer: num_traits::PrimInt + Number {
+    /// Width of the integer, in bits.
+    const WIDTH: usize;
+    /// If the integer is signed: true means signed, false means unsigned.
+    const SIGNED: bool;
+}
+
+/// Abstract trait representing any SPIR-V signed integer type.
+///
+/// # Safety
+/// Implementing this trait on non-signed-integer types breaks assumptions of other unsafe code,
+/// and should not be done.
+pub unsafe trait SignedInteger: num_traits::Signed + Integer {}
+
+/// Abstract trait representing any SPIR-V unsigned integer type.
+///
+/// # Safety
+/// Implementing this trait on non-unsigned-integer types breaks assumptions of other unsafe code,
+/// and should not be done.
+pub unsafe trait UnsignedInteger: num_traits::Unsigned + Integer {}
+
+/// Abstract trait representing a SPIR-V floating point type.
+///
+/// # Safety
+/// Implementing this trait on non-primitive-float types breaks assumptions of other unsafe code,
+/// and should not be done.
+pub unsafe trait Float: num_traits::Float + Number {
+    /// Width of the float, in bits.
+    const WIDTH: usize;
+}
+
 macro_rules! impl_scalar {
-    ($($ty:ty),+) => {
-        $(
-            unsafe impl VectorOrScalar for $ty {
-                type Scalar = Self;
-                const DIM: NonZeroUsize = NonZeroUsize::new(1).unwrap();
-            }
-            unsafe impl Scalar for $ty {}
-        )+
+    (impl Scalar for $ty:ty;) => {
+        impl Sealed for $ty {}
+        unsafe impl VectorOrScalar for $ty {
+            type Scalar = Self;
+            const DIM: NonZeroUsize = NonZeroUsize::new(1).unwrap();
+        }
+        unsafe impl Scalar for $ty {}
+    };
+    (impl Number for $ty:ty;) => {
+        unsafe impl Number for $ty {}
+        impl_scalar!(impl Scalar for $ty;);
+    };
+    (impl UnsignedInteger for $ty:ty;) => {
+        unsafe impl Integer for $ty {
+            const WIDTH: usize = core::mem::size_of::<$ty>() * 8;
+            const SIGNED: bool = false;
+        }
+        unsafe impl UnsignedInteger for $ty {}
+        impl_scalar!(impl Number for $ty;);
+    };
+    (impl SignedInteger for $ty:ty;) => {
+        unsafe impl Integer for $ty {
+            const WIDTH: usize = core::mem::size_of::<$ty>() * 8;
+            const SIGNED: bool = true;
+        }
+        unsafe impl SignedInteger for $ty {}
+        impl_scalar!(impl Number for $ty;);
+    };
+    (impl Float for $ty:ty;) => {
+        unsafe impl Float for $ty {
+            const WIDTH: usize = core::mem::size_of::<$ty>() * 8;
+        }
+        impl_scalar!(impl Number for $ty;);
+    };
+    ($(impl $trait:ident for $ty:ty;)+) => {
+        $(impl_scalar!(impl $trait for $ty;);)+
     };
 }
 
-impl_scalar!(bool, f32, f64, u8, u16, u32, u64, i8, i16, i32, i64);
+impl_scalar! {
+    impl UnsignedInteger for u8;
+    impl UnsignedInteger for u16;
+    impl UnsignedInteger for u32;
+    impl UnsignedInteger for u64;
+    impl SignedInteger for i8;
+    impl SignedInteger for i16;
+    impl SignedInteger for i32;
+    impl SignedInteger for i64;
+    impl Float for f32;
+    impl Float for f64;
+    impl Scalar for bool;
+}

crates/spirv-std/src/number.rs

@@ -2,18 +2,6 @@
 /// of `spirv-std`.
 pub trait Sealed {}
 
-impl Sealed for bool {}
-impl Sealed for f32 {}
-impl Sealed for f64 {}
-impl Sealed for u8 {}
-impl Sealed for u16 {}
-impl Sealed for u32 {}
-impl Sealed for u64 {}
-impl Sealed for i8 {}
-impl Sealed for i16 {}
-impl Sealed for i32 {}
-impl Sealed for i64 {}
-
 impl Sealed for glam::Vec2 {}
 impl Sealed for glam::Vec3 {}
 impl Sealed for glam::Vec4 {}