pub fn split_f64(v: f64) -> (f32, f32) {
let hi = v as f32;
let lo = (v - hi as f64) as f32;
(hi, lo)
}
pub fn split_f64x3(v: [f64; 3]) -> ([f32; 3], [f32; 3]) {
let (x, xl) = split_f64(v[0]);
let (y, yl) = split_f64(v[1]);
let (z, zl) = split_f64(v[2]);
([x, y, z], [xl, yl, zl])
}
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct Origin {
pub position: [f64; 3],
}
impl Origin {
pub const ZERO: Origin = Origin { position: [0.0; 3] };
pub fn new(x: f64, y: f64, z: f64) -> Self {
Self {
position: [x, y, z],
}
}
pub fn to_local(&self, p: [f64; 3]) -> crate::math::Vector3 {
crate::math::Vector3::new(
(p[0] - self.position[0]) as f32,
(p[1] - self.position[1]) as f32,
(p[2] - self.position[2]) as f32,
)
}
pub fn to_world(&self, p: crate::math::Vector3) -> [f64; 3] {
[
self.position[0] + p.x as f64,
self.position[1] + p.y as f64,
self.position[2] + p.z as f64,
]
}
pub fn rebase(&mut self, new_origin: [f64; 3]) -> crate::math::Vector3 {
let delta = crate::math::Vector3::new(
(self.position[0] - new_origin[0]) as f32,
(self.position[1] - new_origin[1]) as f32,
(self.position[2] - new_origin[2]) as f32,
);
self.position = new_origin;
delta
}
pub(crate) fn split(&self) -> ([f32; 4], [f32; 4]) {
let (hi, lo) = split_f64x3(self.position);
([hi[0], hi[1], hi[2], 0.0], [lo[0], lo[1], lo[2], 0.0])
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn split_recovers_what_a_plain_cast_loses() {
let v = 10_000_000.25;
assert_eq!(v as f32 as f64, 10_000_000.0);
let (hi, lo) = split_f64(v);
assert_eq!(hi as f64 + lo as f64, v);
}
#[test]
fn difference_of_splits_keeps_sub_unit_offsets() {
let origin = Origin::new(6_378_137.0, -3_000_000.5, 0.0);
let (ohi, olo) = origin.split();
for k in 0..16 {
let p = 6_378_137.0 + k as f64 * 0.125;
let (hi, lo) = split_f64(p);
let rel = (hi - ohi[0]) + (lo - olo[0]);
assert!(
(rel as f64 - k as f64 * 0.125).abs() < 1e-6,
"{k}: got {rel}"
);
}
}
#[test]
fn rebase_returns_the_shift_for_local_content() {
let mut o = Origin::new(100.0, 0.0, 0.0);
let cam = o.to_local([105.0, 2.0, 0.0]);
let shift = o.rebase([104.0, 0.0, 0.0]);
let moved = cam + shift;
assert_eq!(o.to_world(moved), [105.0, 2.0, 0.0]);
}
}