scalar or vector: rename VectorOrScalar to ScalarOrVector and give it its own mod

Author: Firestar99

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

@@ -1,4 +1,4 @@
-use crate::VectorOrScalar;
+use crate::ScalarOrVector;
 #[cfg(target_arch = "spirv")]
 use crate::arch::barrier;
 #[cfg(target_arch = "spirv")]
@@ -243,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 {
@@ -286,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 {
@@ -319,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 {
@@ -594,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 {
@@ -635,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 {
@@ -676,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 {
@@ -717,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 {
@@ -744,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();
@@ -772,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 {
@@ -1344,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 {
@@ -1427,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/lib.rs

@@ -100,7 +100,7 @@ pub mod ray_tracing;
 mod runtime_array;
 mod sampler;
 mod scalar;
-pub(crate) mod sealed;
+mod scalar_or_vector;
 mod typed_buffer;
 mod vector;
 
@@ -110,6 +110,7 @@ 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::*;
 

crates/spirv-std/src/scalar.rs

@@ -1,6 +1,6 @@
 //! Traits related to scalars.
 
-use crate::VectorOrScalar;
+use crate::ScalarOrVector;
 use crate::sealed::Sealed;
 use core::num::NonZeroUsize;
 
@@ -13,7 +13,7 @@ use core::num::NonZeroUsize;
 ///
 /// # Safety
 /// 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 {}
+pub unsafe trait Scalar: ScalarOrVector<Scalar = Self> + crate::sealed::Sealed {}
 
 /// Abstract trait representing a SPIR-V integer or floating-point type. Unlike [`Scalar`], excludes the boolean type.
 ///
@@ -61,9 +61,9 @@ pub unsafe trait Float: num_traits::Float + Number {
 macro_rules! impl_scalar {
     (impl Scalar for $ty:ty;) => {
         impl Sealed for $ty {}
-        unsafe impl VectorOrScalar for $ty {
+        unsafe impl ScalarOrVector for $ty {
             type Scalar = Self;
-            const DIM: NonZeroUsize = NonZeroUsize::new(1).unwrap();
+            const N: NonZeroUsize = NonZeroUsize::new(1).unwrap();
         }
         unsafe impl Scalar for $ty {}
     };

crates/spirv-std/src/scalar_or_vector.rs

@@ -0,0 +1,20 @@
+use crate::{Scalar, Vector};
+use core::num::NonZeroUsize;
+
+pub(crate) mod sealed {
+    /// A marker trait used to prevent other traits from being implemented outside
+    /// of `spirv-std`.
+    pub trait Sealed {}
+}
+
+/// Abstract trait representing either a [`Scalar`] or [`Vector`] type.
+///
+/// # Safety
+/// Your type must also implement [`Scalar`] or [`Vector`], see their safety sections as well.
+pub unsafe trait ScalarOrVector: Copy + Default + Send + Sync + 'static {
+    /// Either the scalar component type of the vector or the scalar itself.
+    type Scalar: Scalar;
+
+    /// The dimension of the vector, or 1 if it is a scalar
+    const N: NonZeroUsize;
+}

crates/spirv-std/src/sealed.rs

@@ -1,22 +1,10 @@
 //! Traits related to vectors.
 
-use crate::Scalar;
 use crate::sealed::Sealed;
+use crate::{Scalar, ScalarOrVector};
 use core::num::NonZeroUsize;
 use glam::{Vec3Swizzles, Vec4Swizzles};
 
-/// Abstract trait representing either a vector or a scalar type.
-///
-/// # Safety
-/// Your type must also implement [`Vector`] or [`Scalar`], see their safety sections as well.
-pub unsafe trait VectorOrScalar: Copy + Default + Send + Sync + 'static {
-    /// Either the scalar component type of the vector or the scalar itself.
-    type Scalar: Scalar;
-
-    /// The dimension of the vector, or 1 if it is a scalar
-    const DIM: NonZeroUsize;
-}
-
 /// Abstract trait representing a SPIR-V vector type.
 ///
 /// To implement this trait, your struct must be marked with:
@@ -63,15 +51,15 @@ pub unsafe trait VectorOrScalar: Copy + Default + Send + Sync + 'static {
 // While it's possible with `T: Scalar`, it's not with `const N: usize`, since some impl blocks in `image::params` need
 // to be conditional on a specific N value. And you can only express that with const generics, but not with associated
 // constants due to lack of const generics support in rustc.
-pub unsafe trait Vector<T: Scalar, const N: usize>: VectorOrScalar<Scalar = T> {}
+pub unsafe trait Vector<T: Scalar, const N: usize>: ScalarOrVector<Scalar = T> {}
 
 macro_rules! impl_vector {
     ($($ty:ty: [$scalar:ty; $n:literal];)+) => {
         $(
             impl Sealed for $ty {}
-            unsafe impl VectorOrScalar for $ty {
+            unsafe impl ScalarOrVector for $ty {
                 type Scalar = $scalar;
-                const DIM: NonZeroUsize = NonZeroUsize::new($n).unwrap();
+                const N: NonZeroUsize = NonZeroUsize::new($n).unwrap();
             }
             unsafe impl Vector<$scalar, $n> for $ty {}
         )+