Scalar and Vector types refactor

crates/spirv-std/src/arch.rs

@@ -4,12 +4,8 @@
 //! These functions will typically map to a single instruction, and will perform
 //! no additional safety checks beyond type-checking.
 #[cfg(target_arch = "spirv")]
-use crate::integer::Integer;
-use crate::{
-    integer::{SignedInteger, UnsignedInteger},
-    scalar::Scalar,
-    vector::Vector,
-};
+use crate::Integer;
+use crate::{Scalar, SignedInteger, UnsignedInteger, Vector};
 #[cfg(target_arch = "spirv")]
 use core::arch::asm;
 use glam::UVec2;

crates/spirv-std/src/arch/atomics.rs

@@ -1,11 +1,7 @@
 #[cfg(target_arch = "spirv")]
 use core::arch::asm;
 
-use crate::{
-    float::Float,
-    integer::{Integer, SignedInteger, UnsignedInteger},
-    number::Number,
-};
+use crate::{Float, Integer, Number, SignedInteger, UnsignedInteger};
 
 /// Atomically load through `ptr` using the given `SEMANTICS`. All subparts of
 /// the value that is loaded are read atomically with respect to all other

crates/spirv-std/src/arch/subgroup.rs

@@ -1,10 +1,9 @@
+use crate::ScalarOrVector;
 #[cfg(target_arch = "spirv")]
 use crate::arch::barrier;
-use crate::float::Float;
-use crate::integer::{Integer, SignedInteger, UnsignedInteger};
 #[cfg(target_arch = "spirv")]
 use crate::memory::{Scope, Semantics};
-use crate::vector::VectorOrScalar;
+use crate::{Float, Integer, SignedInteger, UnsignedInteger};
 #[cfg(target_arch = "spirv")]
 use core::arch::asm;
 
@@ -244,7 +243,7 @@ pub fn subgroup_any(predicate: bool) -> bool {
 #[spirv_std_macros::gpu_only]
 #[doc(alias = "OpGroupNonUniformAllEqual")]
 #[inline]
-pub fn subgroup_all_equal<T: VectorOrScalar>(value: T) -> bool {
+pub fn subgroup_all_equal<T: ScalarOrVector>(value: T) -> bool {
     let mut result = false;
 
     unsafe {
@@ -287,7 +286,7 @@ pub fn subgroup_all_equal<T: VectorOrScalar>(value: T) -> bool {
 #[spirv_std_macros::gpu_only]
 #[doc(alias = "OpGroupNonUniformBroadcast")]
 #[inline]
-pub unsafe fn subgroup_broadcast<T: VectorOrScalar>(value: T, id: u32) -> T {
+pub unsafe fn subgroup_broadcast<T: ScalarOrVector>(value: T, id: u32) -> T {
     let mut result = T::default();
 
     unsafe {
@@ -320,7 +319,7 @@ pub unsafe fn subgroup_broadcast<T: VectorOrScalar>(value: T, id: u32) -> T {
 #[spirv_std_macros::gpu_only]
 #[doc(alias = "OpGroupNonUniformBroadcastFirst")]
 #[inline]
-pub fn subgroup_broadcast_first<T: VectorOrScalar>(value: T) -> T {
+pub fn subgroup_broadcast_first<T: ScalarOrVector>(value: T) -> T {
     let mut result = T::default();
 
     unsafe {
@@ -595,7 +594,7 @@ pub fn subgroup_ballot_find_msb(value: SubgroupMask) -> u32 {
 #[spirv_std_macros::gpu_only]
 #[doc(alias = "OpGroupNonUniformShuffle")]
 #[inline]
-pub fn subgroup_shuffle<T: VectorOrScalar>(value: T, id: u32) -> T {
+pub fn subgroup_shuffle<T: ScalarOrVector>(value: T, id: u32) -> T {
     let mut result = T::default();
 
     unsafe {
@@ -636,7 +635,7 @@ pub fn subgroup_shuffle<T: VectorOrScalar>(value: T, id: u32) -> T {
 #[spirv_std_macros::gpu_only]
 #[doc(alias = "OpGroupNonUniformShuffleXor")]
 #[inline]
-pub fn subgroup_shuffle_xor<T: VectorOrScalar>(value: T, mask: u32) -> T {
+pub fn subgroup_shuffle_xor<T: ScalarOrVector>(value: T, mask: u32) -> T {
     let mut result = T::default();
 
     unsafe {
@@ -677,7 +676,7 @@ pub fn subgroup_shuffle_xor<T: VectorOrScalar>(value: T, mask: u32) -> T {
 #[spirv_std_macros::gpu_only]
 #[doc(alias = "OpGroupNonUniformShuffleUp")]
 #[inline]
-pub fn subgroup_shuffle_up<T: VectorOrScalar>(value: T, delta: u32) -> T {
+pub fn subgroup_shuffle_up<T: ScalarOrVector>(value: T, delta: u32) -> T {
     let mut result = T::default();
 
     unsafe {
@@ -718,7 +717,7 @@ pub fn subgroup_shuffle_up<T: VectorOrScalar>(value: T, delta: u32) -> T {
 #[spirv_std_macros::gpu_only]
 #[doc(alias = "OpGroupNonUniformShuffleDown")]
 #[inline]
-pub fn subgroup_shuffle_down<T: VectorOrScalar>(value: T, delta: u32) -> T {
+pub fn subgroup_shuffle_down<T: ScalarOrVector>(value: T, delta: u32) -> T {
     let mut result = T::default();
 
     unsafe {
@@ -745,7 +744,7 @@ macro_rules! macro_subgroup_op {
         #[spirv_std_macros::gpu_only]
         #[doc(alias = $asm_op)]
         #[inline]
-        pub fn $name<I: VectorOrScalar<Scalar = $scalar>>(
+        pub fn $name<I: ScalarOrVector<Scalar = $scalar>>(
             value: I,
         ) -> I {
             let mut result = I::default();
@@ -773,7 +772,7 @@ macro_rules! macro_subgroup_op_clustered {
         #[spirv_std_macros::gpu_only]
         #[doc(alias = $asm_op)]
         #[inline]
-        pub unsafe fn $name<const CLUSTER_SIZE: u32, I: VectorOrScalar<Scalar = $scalar>>(
+        pub unsafe fn $name<const CLUSTER_SIZE: u32, I: ScalarOrVector<Scalar = $scalar>>(
             value: I,
         ) -> I {
             const {
@@ -1345,7 +1344,7 @@ Requires Capability `GroupNonUniformArithmetic` and `GroupNonUniformClustered`.
 #[spirv_std_macros::gpu_only]
 #[doc(alias = "OpGroupNonUniformQuadBroadcast")]
 #[inline]
-pub fn subgroup_quad_broadcast<T: VectorOrScalar>(value: T, index: u32) -> T {
+pub fn subgroup_quad_broadcast<T: ScalarOrVector>(value: T, index: u32) -> T {
     let mut result = T::default();
 
     unsafe {
@@ -1428,7 +1427,7 @@ pub enum QuadDirection {
 #[spirv_std_macros::gpu_only]
 #[doc(alias = "OpGroupNonUniformQuadSwap")]
 #[inline]
-pub fn subgroup_quad_swap<const DIRECTION: u32, T: VectorOrScalar>(value: T) -> T {
+pub fn subgroup_quad_swap<const DIRECTION: u32, T: ScalarOrVector>(value: T) -> T {
     let mut result = T::default();
 
     unsafe {

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/image.rs

@@ -1,24 +1,21 @@
 //! Image types
 
+pub use self::params::{ImageCoordinate, ImageCoordinateSubpassData, ImageSizeQuery, SampleType};
 #[cfg(target_arch = "spirv")]
-use crate::vector::VectorTruncateInto;
+use crate::VectorTruncateInto;
+pub use crate::macros::Image;
+use crate::{Float, Integer, Sampler, Vector};
 #[cfg(target_arch = "spirv")]
 use core::arch::asm;
-
-mod params;
-
-/// Contains extra image operands
-pub mod sample_with;
-
-pub use self::params::{ImageCoordinate, ImageCoordinateSubpassData, ImageSizeQuery, SampleType};
-pub use crate::macros::Image;
+use sample_with::{NoneTy, SampleParams, SomeTy};
 pub use spirv_std_types::image_params::{
     AccessQualifier, Arrayed, Dimensionality, ImageDepth, ImageFormat, Multisampled, Sampled,
 };
 
-use sample_with::{NoneTy, SampleParams, SomeTy};
+mod params;
 
-use crate::{Sampler, float::Float, integer::Integer, vector::Vector};
+/// Contains extra image operands
+pub mod sample_with;
 
 /// Re-export of primitive types to ensure the `Image` proc macro always points
 /// to the right type.

crates/spirv-std/src/image/params.rs

@@ -1,5 +1,5 @@
 use super::{Arrayed, Dimensionality, ImageFormat};
-use crate::{integer::Integer, scalar::Scalar, vector::Vector, vector::VectorTruncateInto};
+use crate::{Integer, Scalar, Vector, VectorTruncateInto};
 
 /// Marker trait for arguments that accept single scalar values or vectors
 /// of scalars. Defines 2-, 3- and 4-component vector types based on the sample type.

crates/spirv-std/src/lib.rs

@@ -94,24 +94,25 @@ pub mod byte_addressable_buffer;
 pub mod float;
 pub mod image;
 pub mod indirect_command;
-pub mod integer;
 pub mod matrix;
 pub mod memory;
-pub mod number;
 pub mod ray_tracing;
 mod runtime_array;
 mod sampler;
-pub mod scalar;
-pub(crate) mod sealed;
+mod scalar;
+mod scalar_or_vector;
 mod typed_buffer;
-pub mod vector;
+mod vector;
 
 pub use self::sampler::Sampler;
 pub use crate::macros::Image;
 pub use byte_addressable_buffer::ByteAddressableBuffer;
 pub use num_traits;
 pub use runtime_array::*;
+pub use scalar::*;
+pub use scalar_or_vector::*;
 pub use typed_buffer::*;
+pub use vector::*;
 
 pub use glam;
 
@@ -136,11 +137,7 @@ pub fn debug_printf_assert_is_type<T>(ty: T) -> T {
 }
 
 #[doc(hidden)]
-pub fn debug_printf_assert_is_vector<
-    TY: crate::scalar::Scalar,
-    V: crate::vector::Vector<TY, SIZE>,
-    const SIZE: usize,
->(
+pub fn debug_printf_assert_is_vector<TY: Scalar, V: Vector<TY, SIZE>, const SIZE: usize>(
     vec: V,
 ) -> V {
     vec