spirv_backend: remove Vec3Std and use coremem_types::Vec3 everywhere

crates/coremem/src/sim/spirv/bindings.rs

@@ -9,7 +9,7 @@ use crate::geom::{Index, Vec3, Vec3u};
 mod ffi {
     pub use spirv_backend::entry_points;
     pub use spirv_backend::sim::SerializedSimMeta;
-    pub use spirv_backend::support::{Optional, Vec3Std};
+    pub use spirv_backend::support::Optional;
     pub use spirv_backend::mat::{Ferroxcube3R1MH, FullyGenericMaterial, IsoConductorOr, Material, MBPgram, MHPgram};
 }
 
@@ -53,9 +53,11 @@ macro_rules! identity {
 }
 
 // XXX: should work for any other lifetime, not just 'static
+identity!(=> f32);
 identity!(=> &'static str);
 identity!(T0, T1, => (T0, T1));
 identity!(=> Vec3u);
+identity!(T, => Vec3<T>);
 
 impl<L: IntoFfi> IntoFfi for Option<L>
     where L::Ffi: Default
@@ -80,19 +82,6 @@ impl<F: Copy + IntoLib> IntoLib for ffi::Optional<F> {
     }
 }
 
-impl IntoFfi for Vec3<f32> {
-    type Ffi = ffi::Vec3Std;
-    fn into_ffi(self) -> Self::Ffi {
-        Self::Ffi::new(self.x(), self.y(), self.z())
-    }
-}
-impl IntoLib for ffi::Vec3Std {
-    type Lib = Vec3<f32>;
-    fn into_lib(self) -> Self::Lib {
-        Self::Lib::new(self.x(), self.y(), self.z())
-    }
-}
-
 impl IntoFfi for MBPgram<f32> {
     type Ffi = ffi::MBPgram;
     fn into_ffi(self) -> Self::Ffi {

crates/coremem/src/sim/spirv/mod.rs

@@ -744,7 +744,7 @@ mod test {
         use super::*;
         use crate::sim::Meters;
         use crate::stim::{NoopStimulus, RngStimulus};
-        use spirv_backend::{step_e_generic_material as step_e, step_h_generic_material as step_h, UVec3};
+        use spirv_backend::{step_e_generic_material as step_e, step_h_generic_material as step_h, glam};
 
         fn do_step<S: AbstractStimulus>(state: &mut SpirvSim, stim: &S) {
             let meta = state.meta.clone();
@@ -766,7 +766,7 @@ mod test {
             for z in 0..meta.dim.z() {
                 for y in 0..meta.dim.y() {
                     for x in 0..meta.dim.x() {
-                        step_e(UVec3::new(x, y, z), meta_for_step, stim_e, stim_h, mat, e, h, m);
+                        step_e(glam::UVec3::new(x, y, z), meta_for_step, stim_e, stim_h, mat, e, h, m);
                     }
                 }
             }
@@ -774,7 +774,7 @@ mod test {
             for z in 0..meta.dim.z() {
                 for y in 0..meta.dim.y() {
                     for x in 0..meta.dim.x() {
-                        step_h(UVec3::new(x, y, z), meta_for_step, stim_e, stim_h, mat, e, h, m);
+                        step_h(glam::UVec3::new(x, y, z), meta_for_step, stim_e, stim_h, mat, e, h, m);
                     }
                 }
             }

crates/spirv_backend/src/lib.rs

@@ -8,7 +8,7 @@
 
 extern crate spirv_std;
 
-pub use spirv_std::glam::{UVec3, Vec3};
+pub use spirv_std::glam;
 #[cfg(not(target_arch = "spirv"))]
 use spirv_std::macros::spirv;
 
@@ -17,26 +17,27 @@ pub mod sim;
 pub mod support;
 
 pub use sim::{SerializedSimMeta, SerializedStepE, SerializedStepH};
-pub use support::{Optional, UnsizedArray, Vec3Std};
+pub use support::{Optional, UnsizedArray};
 
 use mat::{IsoConductorOr, Ferroxcube3R1MH, FullyGenericMaterial, Material};
 
 use coremem_types::vecu::Vec3u;
+use coremem_types::vec::Vec3;
 
 type Iso3R1 = IsoConductorOr<Ferroxcube3R1MH>;
 
-fn glam_vec_to_internal(v: UVec3) -> Vec3u {
+fn glam_vec_to_internal(v: glam::UVec3) -> Vec3u {
     Vec3u::new(v.x, v.y, v.z)
 }
 
 fn step_h<M: Material>(
     id: Vec3u,
     meta: &SerializedSimMeta,
-    stimulus_h: &UnsizedArray<Vec3Std>,
+    stimulus_h: &UnsizedArray<Vec3<f32>>,
     material: &UnsizedArray<M>,
-    e: &UnsizedArray<Vec3Std>,
+    e: &UnsizedArray<Vec3<f32>>,
-    h: &mut UnsizedArray<Vec3Std>,
+    h: &mut UnsizedArray<Vec3<f32>>,
-    m: &mut UnsizedArray<Vec3Std>,
+    m: &mut UnsizedArray<Vec3<f32>>,
 ) {
     if id.x() < meta.dim.x() && id.y() < meta.dim.y() && id.z() < meta.dim.z() {
         let sim_state = SerializedStepH::new(meta, stimulus_h, material, e, h, m);
@@ -48,10 +49,10 @@ fn step_h<M: Material>(
 fn step_e<M: Material>(
     id: Vec3u,
     meta: &SerializedSimMeta,
-    stimulus_e: &UnsizedArray<Vec3Std>,
+    stimulus_e: &UnsizedArray<Vec3<f32>>,
     material: &UnsizedArray<M>,
-    e: &mut UnsizedArray<Vec3Std>,
+    e: &mut UnsizedArray<Vec3<f32>>,
-    h: &UnsizedArray<Vec3Std>,
+    h: &UnsizedArray<Vec3<f32>>,
 ) {
     if id.x() < meta.dim.x() && id.y() < meta.dim.y() && id.z() < meta.dim.z() {
         let sim_state = SerializedStepE::new(meta, stimulus_e, material, e, h);
@@ -86,31 +87,31 @@ macro_rules! steps {
         // LocalSize/numthreads
         #[spirv(compute(threads(4, 4, 4)))]
         pub fn $step_h(
-            #[spirv(global_invocation_id)] id: UVec3,
+            #[spirv(global_invocation_id)] id: glam::UVec3,
             #[spirv(storage_buffer, descriptor_set = 0, binding = 0)] meta: &SerializedSimMeta,
             // XXX: delete this input?
-            #[spirv(storage_buffer, descriptor_set = 0, binding = 1)] _unused_stimulus_e: &UnsizedArray<Vec3Std>,
+            #[spirv(storage_buffer, descriptor_set = 0, binding = 1)] _unused_stimulus_e: &UnsizedArray<Vec3<f32>>,
-            #[spirv(storage_buffer, descriptor_set = 0, binding = 2)] stimulus_h: &UnsizedArray<Vec3Std>,
+            #[spirv(storage_buffer, descriptor_set = 0, binding = 2)] stimulus_h: &UnsizedArray<Vec3<f32>>,
             #[spirv(storage_buffer, descriptor_set = 0, binding = 3)] material: &UnsizedArray<$mat>,
-            #[spirv(storage_buffer, descriptor_set = 0, binding = 4)] e: &UnsizedArray<Vec3Std>,
+            #[spirv(storage_buffer, descriptor_set = 0, binding = 4)] e: &UnsizedArray<Vec3<f32>>,
-            #[spirv(storage_buffer, descriptor_set = 0, binding = 5)] h: &mut UnsizedArray<Vec3Std>,
+            #[spirv(storage_buffer, descriptor_set = 0, binding = 5)] h: &mut UnsizedArray<Vec3<f32>>,
-            #[spirv(storage_buffer, descriptor_set = 0, binding = 6)] m: &mut UnsizedArray<Vec3Std>,
+            #[spirv(storage_buffer, descriptor_set = 0, binding = 6)] m: &mut UnsizedArray<Vec3<f32>>,
         ) {
             step_h(glam_vec_to_internal(id), meta, stimulus_h, material, e, h, m)
         }
 
         #[spirv(compute(threads(4, 4, 4)))]
         pub fn $step_e(
-            #[spirv(global_invocation_id)] id: UVec3,
+            #[spirv(global_invocation_id)] id: glam::UVec3,
             #[spirv(storage_buffer, descriptor_set = 0, binding = 0)] meta: &SerializedSimMeta,
-            #[spirv(storage_buffer, descriptor_set = 0, binding = 1)] stimulus_e: &UnsizedArray<Vec3Std>,
+            #[spirv(storage_buffer, descriptor_set = 0, binding = 1)] stimulus_e: &UnsizedArray<Vec3<f32>>,
             // XXX: delete this input?
-            #[spirv(storage_buffer, descriptor_set = 0, binding = 2)] _unused_stimulus_h: &UnsizedArray<Vec3Std>,
+            #[spirv(storage_buffer, descriptor_set = 0, binding = 2)] _unused_stimulus_h: &UnsizedArray<Vec3<f32>>,
             #[spirv(storage_buffer, descriptor_set = 0, binding = 3)] material: &UnsizedArray<$mat>,
-            #[spirv(storage_buffer, descriptor_set = 0, binding = 4)] e: &mut UnsizedArray<Vec3Std>,
+            #[spirv(storage_buffer, descriptor_set = 0, binding = 4)] e: &mut UnsizedArray<Vec3<f32>>,
-            #[spirv(storage_buffer, descriptor_set = 0, binding = 5)] h: &UnsizedArray<Vec3Std>,
+            #[spirv(storage_buffer, descriptor_set = 0, binding = 5)] h: &UnsizedArray<Vec3<f32>>,
             // XXX: can/should this m input be deleted?
-            #[spirv(storage_buffer, descriptor_set = 0, binding = 6)] _unused_m: &UnsizedArray<Vec3Std>,
+            #[spirv(storage_buffer, descriptor_set = 0, binding = 6)] _unused_m: &UnsizedArray<Vec3<f32>>,
         ) {
             step_e(glam_vec_to_internal(id), meta, stimulus_e, material, e, h)
         }

crates/spirv_backend/src/mat.rs

@@ -1,11 +1,12 @@
-use crate::support::{Optional, Vec3Std};
+use crate::support::Optional;
+use coremem_types::vec::Vec3;
 
 pub trait Material: Sized {
-    fn conductivity(&self) -> Vec3Std {
+    fn conductivity(&self) -> Vec3<f32> {
         Default::default()
     }
     /// returns the new M vector for this material
-    fn move_b_vec(&self, m: Vec3Std, _target_b: Vec3Std) -> Vec3Std {
+    fn move_b_vec(&self, m: Vec3<f32>, _target_b: Vec3<f32>) -> Vec3<f32> {
         // XXX could return either 0, or `m`. they should be the same, but one might be more
         // optimizable than the other (untested).
         m
@@ -14,18 +15,18 @@ pub trait Material: Sized {
 
 #[derive(Copy, Clone, Default, PartialEq)]
 pub struct Conductor<T>(pub T);
-pub type AnisomorphicConductor = Conductor<Vec3Std>;
+pub type AnisomorphicConductor = Conductor<Vec3<f32>>;
 pub type IsomorphicConductor = Conductor<f32>;
 
 impl Material for AnisomorphicConductor {
-    fn conductivity(&self) -> Vec3Std {
+    fn conductivity(&self) -> Vec3<f32> {
         self.0
     }
 }
 
 impl Material for IsomorphicConductor {
-    fn conductivity(&self) -> Vec3Std {
+    fn conductivity(&self) -> Vec3<f32> {
-        Vec3Std::uniform(self.0)
+        Vec3::uniform(self.0)
     }
 }
 
@@ -79,8 +80,8 @@ impl MBPgram {
 }
 
 impl Material for MBPgram {
-    fn move_b_vec(&self, m: Vec3Std, target_b: Vec3Std) -> Vec3Std {
+    fn move_b_vec(&self, m: Vec3<f32>, target_b: Vec3<f32>) -> Vec3<f32> {
-        Vec3Std::new(
+        Vec3::new(
             self.move_b(m.x(), target_b.x()),
             self.move_b(m.y(), target_b.y()),
             self.move_b(m.z(), target_b.z()),
@@ -167,8 +168,8 @@ impl MHPgram {
 }
 
 impl Material for MHPgram {
-    fn move_b_vec(&self, m: Vec3Std, target_b: Vec3Std) -> Vec3Std {
+    fn move_b_vec(&self, m: Vec3<f32>, target_b: Vec3<f32>) -> Vec3<f32> {
-        Vec3Std::new(
+        Vec3::new(
             self.move_b(m.x(), target_b.x()),
             self.move_b(m.y(), target_b.y()),
             self.move_b(m.z(), target_b.z()),
@@ -178,16 +179,16 @@ impl Material for MHPgram {
 
 #[derive(Copy, Clone, Default, PartialEq)]
 pub struct FullyGenericMaterial {
-    pub conductivity: Vec3Std,
+    pub conductivity: Vec3<f32>,
     pub m_b_curve: Optional<MBPgram>,
     pub m_h_curve: Optional<MHPgram>,
 }
 
 impl Material for FullyGenericMaterial {
-    fn conductivity(&self) -> Vec3Std {
+    fn conductivity(&self) -> Vec3<f32> {
         self.conductivity
     }
-    fn move_b_vec(&self, m: Vec3Std, target_b: Vec3Std) -> Vec3Std {
+    fn move_b_vec(&self, m: Vec3<f32>, target_b: Vec3<f32>) -> Vec3<f32> {
         if self.m_b_curve.is_some() {
             self.m_b_curve.unwrap().move_b_vec(m, target_b)
         } else if self.m_h_curve.is_some() {
@@ -210,7 +211,7 @@ impl Into<MHPgram> for Ferroxcube3R1MH {
 }
 
 impl Material for Ferroxcube3R1MH {
-    fn move_b_vec(&self, m: Vec3Std, target_b: Vec3Std) -> Vec3Std {
+    fn move_b_vec(&self, m: Vec3<f32>, target_b: Vec3<f32>) -> Vec3<f32> {
         let curve: MHPgram = (*self).into();
         curve.move_b_vec(m, target_b)
     }
@@ -241,10 +242,10 @@ impl<M: Default> IsoConductorOr<M> {
 }
 
 impl<M: Material + Copy> Material for IsoConductorOr<M> {
-    fn conductivity(&self) -> Vec3Std {
+    fn conductivity(&self) -> Vec3<f32> {
-        Vec3Std::uniform(self.value.max(0.0))
+        Vec3::uniform(self.value.max(0.0))
     }
-    fn move_b_vec(&self, m: Vec3Std, target_b: Vec3Std) -> Vec3Std {
+    fn move_b_vec(&self, m: Vec3<f32>, target_b: Vec3<f32>) -> Vec3<f32> {
         if self.value < 0.0 {
             let mat = self.mat;  //< XXX hack for ZST
             mat.move_b_vec(m, target_b)

crates/spirv_backend/src/sim.rs

@@ -1,8 +1,9 @@
 // use spirv_std::RuntimeArray;
 use crate::mat::Material;
 use crate::support::{
-    Array3, Array3Mut, ArrayHandle, ArrayHandleMut, Optional, UnsizedArray, Vec3Std
+    Array3, Array3Mut, ArrayHandle, ArrayHandleMut, Optional, UnsizedArray
 };
+use coremem_types::vec::Vec3;
 use coremem_types::vecu::Vec3u;
 
 #[derive(Copy, Clone)]
@@ -17,21 +18,21 @@ pub struct SerializedSimMeta {
 /// Whatever data we received from the host in their call to step_h
 pub struct SerializedStepH<'a, M> {
     meta: &'a SerializedSimMeta,
-    stimulus_h: &'a UnsizedArray<Vec3Std>,
+    stimulus_h: &'a UnsizedArray<Vec3<f32>>,
     material: &'a UnsizedArray<M>,
-    e: &'a UnsizedArray<Vec3Std>,
+    e: &'a UnsizedArray<Vec3<f32>>,
-    h: &'a mut UnsizedArray<Vec3Std>,
+    h: &'a mut UnsizedArray<Vec3<f32>>,
-    m: &'a mut UnsizedArray<Vec3Std>,
+    m: &'a mut UnsizedArray<Vec3<f32>>,
 }
 
 impl<'a, M> SerializedStepH<'a, M> {
     pub fn new(
         meta: &'a SerializedSimMeta,
-        stimulus_h: &'a UnsizedArray<Vec3Std>,
+        stimulus_h: &'a UnsizedArray<Vec3<f32>>,
         material: &'a UnsizedArray<M>,
-        e: &'a UnsizedArray<Vec3Std>,
+        e: &'a UnsizedArray<Vec3<f32>>,
-        h: &'a mut UnsizedArray<Vec3Std>,
+        h: &'a mut UnsizedArray<Vec3<f32>>,
-        m: &'a mut UnsizedArray<Vec3Std>,
+        m: &'a mut UnsizedArray<Vec3<f32>>,
     ) -> Self {
         Self {
             meta, stimulus_h, material, e, h, m
@@ -72,19 +73,19 @@ impl<'a, M> SerializedStepH<'a, M> {
 /// Whatever data we received from the host in their call to step_e
 pub struct SerializedStepE<'a, M> {
     meta: &'a SerializedSimMeta,
-    stimulus_e: &'a UnsizedArray<Vec3Std>,
+    stimulus_e: &'a UnsizedArray<Vec3<f32>>,
     material: &'a UnsizedArray<M>,
-    e: &'a mut UnsizedArray<Vec3Std>,
+    e: &'a mut UnsizedArray<Vec3<f32>>,
-    h: &'a UnsizedArray<Vec3Std>,
+    h: &'a UnsizedArray<Vec3<f32>>,
 }
 
 impl<'a, M> SerializedStepE<'a, M> {
     pub fn new(
         meta: &'a SerializedSimMeta,
-        stimulus_e: &'a UnsizedArray<Vec3Std>,
+        stimulus_e: &'a UnsizedArray<Vec3<f32>>,
         material: &'a UnsizedArray<M>,
-        e: &'a mut UnsizedArray<Vec3Std>,
+        e: &'a mut UnsizedArray<Vec3<f32>>,
-        h: &'a UnsizedArray<Vec3Std>,
+        h: &'a UnsizedArray<Vec3<f32>>,
     ) -> Self {
         Self {
             meta, stimulus_e, material, e, h
@@ -140,10 +141,10 @@ impl<'a, M> SerializedStepE<'a, M> {
 /// This is used in step_e when looking at the H field deltas.
 #[derive(Copy, Clone)]
 struct VolumeSampleNeg {
-    mid: Vec3Std,
+    mid: Vec3<f32>,
-    xm1: Optional<Vec3Std>,
+    xm1: Optional<Vec3<f32>>,
-    ym1: Optional<Vec3Std>,
+    ym1: Optional<Vec3<f32>>,
-    zm1: Optional<Vec3Std>,
+    zm1: Optional<Vec3<f32>>,
 }
 
 impl VolumeSampleNeg {
@@ -197,10 +198,10 @@ impl VolumeSampleNeg {
 /// This is used in step_h when looking at the E field deltas.
 #[derive(Copy, Clone)]
 struct VolumeSamplePos {
-    mid: Vec3Std,
+    mid: Vec3<f32>,
-    xp1: Optional<Vec3Std>,
+    xp1: Optional<Vec3<f32>>,
-    yp1: Optional<Vec3Std>,
+    yp1: Optional<Vec3<f32>>,
-    zp1: Optional<Vec3Std>
+    zp1: Optional<Vec3<f32>>
 }
 
 impl VolumeSamplePos {
@@ -258,8 +259,8 @@ struct FieldDeltas {
 }
 
 impl FieldDeltas {
-    fn nabla(self) -> Vec3Std {
+    fn nabla(self) -> Vec3<f32> {
-        Vec3Std::new(
+        Vec3::new(
             self.dfz_dy - self.dfy_dz,
             self.dfx_dz - self.dfz_dx,
             self.dfy_dx - self.dfx_dy,
@@ -270,12 +271,12 @@ impl FieldDeltas {
 pub struct StepEContext<'a, M> {
     inv_feature_size: f32,
     time_step: f32,
-    stim_e: Vec3Std,
+    stim_e: Vec3<f32>,
     mat: ArrayHandle<'a, M>,
     /// Input field sampled near this location
     in_h: VolumeSampleNeg,
     /// Handle to the output field at one specific index.
-    out_e: ArrayHandleMut<'a, Vec3Std>,
+    out_e: ArrayHandleMut<'a, Vec3<f32>>,
 }
 
 impl<'a, M: Material> StepEContext<'a, M> {
@@ -291,7 +292,7 @@ impl<'a, M: Material> StepEContext<'a, M> {
         let sigma = self.mat.get_ref().conductivity();
         let e_prev = self.out_e.get();
         let delta_e = (nabla_h - e_prev.elem_mul(sigma)).elem_div(
-            sigma*self.time_step + Vec3Std::uniform(TWICE_EPS0)
+            sigma*self.time_step + Vec3::uniform(TWICE_EPS0)
         )*(2.0*self.time_step);
         // println!("spirv-step_e delta_e: {:?}", delta_e);
         self.out_e.write(e_prev + delta_e + self.stim_e);
@@ -302,13 +303,13 @@ impl<'a, M: Material> StepEContext<'a, M> {
 pub struct StepHContext<'a, M> {
     inv_feature_size: f32,
     time_step: f32,
-    stim_h: Vec3Std,
+    stim_h: Vec3<f32>,
     mat: ArrayHandle<'a, M>,
     /// Input field sampled near this location
     in_e: VolumeSamplePos,
     /// Handle to the output field at one specific index.
-    out_h: ArrayHandleMut<'a, Vec3Std>,
+    out_h: ArrayHandleMut<'a, Vec3<f32>>,
-    out_m: ArrayHandleMut<'a, Vec3Std>,
+    out_m: ArrayHandleMut<'a, Vec3<f32>>,
 }
 
 impl<'a, M: Material> StepHContext<'a, M> {

crates/spirv_backend/src/support.rs

@@ -1,11 +1,5 @@
-use coremem_types::vec;
 use coremem_types::vecu::Vec3u;
 
-#[derive(Clone, Copy, Default, PartialEq)]
-pub struct XYZStd<T>(T, T, T);
-
-pub type Vec3Std = vec::Vec3<f32>;
-
 /// This is a spirv-compatible option type.
 /// The native rust Option type produces invalid spirv due to its enum nature; this custom option
 /// type creates code which will actually compile.