Introduce two new unit vector types for MVector

These new types are MPoint and MDirection

Author: patowen

client/src/graphics/frustum.rs

@@ -1,5 +1,5 @@
 use common::Plane;
-use common::math::MVector;
+use common::math::MPoint;
 
 #[derive(Debug, Copy, Clone)]
 pub struct Frustum {
@@ -80,7 +80,7 @@ pub struct FrustumPlanes {
 }
 
 impl FrustumPlanes {
-    pub fn contain(&self, point: &MVector<f32>, radius: f32) -> bool {
+    pub fn contain(&self, point: &MPoint<f32>, radius: f32) -> bool {
         for &plane in &[&self.left, &self.right, &self.down, &self.up] {
             if plane.distance_to(point) < -radius {
                 return false;
@@ -101,29 +101,29 @@ mod tests {
     fn planes_sanity() {
         // 90 degree square
         let planes = Frustum::from_vfov(f32::consts::FRAC_PI_4, 1.0).planes();
-        assert!(planes.contain(&MVector::origin(), 0.1));
+        assert!(planes.contain(&MPoint::origin(), 0.1));
         assert!(planes.contain(
-            &(MIsometry::translation_along(&-na::Vector3::z()) * MVector::origin()),
+            &(MIsometry::translation_along(&-na::Vector3::z()) * MPoint::origin()),
             0.0
         ));
         assert!(!planes.contain(
-            &(MIsometry::translation_along(&na::Vector3::z()) * MVector::origin()),
+            &(MIsometry::translation_along(&na::Vector3::z()) * MPoint::origin()),
             0.0
         ));
         assert!(!planes.contain(
-            &(MIsometry::translation_along(&na::Vector3::x()) * MVector::origin()),
+            &(MIsometry::translation_along(&na::Vector3::x()) * MPoint::origin()),
             0.0
         ));
         assert!(!planes.contain(
-            &(MIsometry::translation_along(&na::Vector3::y()) * MVector::origin()),
+            &(MIsometry::translation_along(&na::Vector3::y()) * MPoint::origin()),
             0.0
         ));
         assert!(!planes.contain(
-            &(MIsometry::translation_along(&-na::Vector3::x()) * MVector::origin()),
+            &(MIsometry::translation_along(&-na::Vector3::x()) * MPoint::origin()),
             0.0
         ));
         assert!(!planes.contain(
-            &(MIsometry::translation_along(&-na::Vector3::y()) * MVector::origin()),
+            &(MIsometry::translation_along(&-na::Vector3::y()) * MPoint::origin()),
             0.0
         ));
     }

client/src/graphics/voxels/mod.rs

@@ -16,11 +16,11 @@ use crate::{
     loader::{Cleanup, LoadCtx, LoadFuture, Loadable, WorkQueue},
 };
 use common::{
-    LruSlab, dodeca,
-    dodeca::Vertex,
+    LruSlab,
+    dodeca::{self, Vertex},
     graph::NodeId,
     lru_slab::SlotId,
-    math::{MIsometry, MVector},
+    math::{MIsometry, MPoint},
     node::{Chunk, ChunkId, VoxelData},
 };
 
@@ -127,7 +127,7 @@ impl Voxels {
             let mut workqueue_is_full = false;
             for &(node, ref node_transform) in nearby_nodes {
                 let node_to_view = local_to_view * node_transform;
-                let origin = node_to_view * MVector::origin();
+                let origin = node_to_view * MPoint::origin();
                 if !frustum_planes.contain(&origin, dodeca::BOUNDING_SPHERE_RADIUS) {
                     // Don't bother generating or drawing chunks from nodes that are wholly outside the
                     // frustum.

client/src/sim.rs

@@ -12,7 +12,7 @@ use common::{
     collision_math::Ray,
     graph::{Graph, NodeId},
     graph_ray_casting,
-    math::{MIsometry, MVector},
+    math::{MDirection, MIsometry, MPoint},
     node::{ChunkId, VoxelData, populate_fresh_nodes},
     proto::{
         self, BlockUpdate, Character, CharacterInput, CharacterState, Command, Component,
@@ -549,7 +549,7 @@ impl Sim {
         let ray_casing_result = graph_ray_casting::ray_cast(
             &self.graph,
             &view_position,
-            &Ray::new(MVector::w(), -MVector::z()),
+            &Ray::new(MPoint::w(), -MDirection::z()),
             self.cfg.character.block_reach,
         );
 

common/src/character_controller/collision.rs

@@ -6,7 +6,7 @@ use crate::{
     collision_math::Ray,
     graph::Graph,
     graph_collision,
-    math::{MIsometry, MVector},
+    math::{MDirection, MIsometry, MPoint},
     proto::Position,
 };
 
@@ -17,7 +17,6 @@ pub fn check_collision(
     relative_displacement: &na::Vector3<f32>,
 ) -> CollisionCheckingResult {
     // Split relative_displacement into its norm and a unit vector
-    let relative_displacement = relative_displacement.to_homogeneous();
     let displacement_sqr = relative_displacement.norm_squared();
     if displacement_sqr < 1e-16 {
         // Fallback for if the displacement vector isn't large enough to reliably be normalized.
@@ -26,11 +25,12 @@ pub fn check_collision(
     }
 
     let displacement_norm = displacement_sqr.sqrt();
-    let displacement_normalized = relative_displacement / displacement_norm;
+    let displacement_normalized =
+        na::UnitVector3::new_unchecked(relative_displacement / displacement_norm);
 
     let ray = Ray::new(
-        MVector::origin(),
-        MVector::<f32>::from(displacement_normalized),
+        MPoint::origin(),
+        MDirection::<f32>::from(displacement_normalized),
     );
     let tanh_distance = displacement_norm.tanh();
 

common/src/chunk_collision.rs

@@ -1,7 +1,6 @@
 use crate::{
     collision_math::Ray,
-    math,
-    math::MVector,
+    math::{MVector, PermuteXYZ},
     node::{ChunkLayout, VoxelAABB, VoxelData},
     voxel_math::Coords,
     world::Material,
@@ -91,8 +90,9 @@ fn find_face_collision(
     for t in bounding_box.grid_planes(t_axis) {
         // Find a normal to the grid plane. Note that (t, 0, 0, x) is a normal of the plane whose closest point
         // to the origin is (x, 0, 0, t), and we use that fact here.
-        let normal = math::tuv_to_xyz(t_axis, MVector::new(1.0, 0.0, 0.0, layout.grid_to_dual(t)))
-            .normalized();
+        let normal = MVector::new(1.0, 0.0, 0.0, layout.grid_to_dual(t))
+            .tuv_to_xyz(t_axis)
+            .normalized_direction();
 
         let Some(new_tanh_distance) =
             ray.solve_sphere_plane_intersection(&normal, collider_radius.sinh())
@@ -121,7 +121,7 @@ fn find_face_collision(
         };
 
         let ray_endpoint = ray.ray_point(new_tanh_distance);
-        let contact_point = ray_endpoint - normal * ray_endpoint.mip(&normal);
+        let contact_point = ray_endpoint - normal.as_ref() * ray_endpoint.mip(&normal);
 
         // Compute the u and v-coordinates of the voxels at the contact point
         let Some(voxel_u) = layout.dual_to_voxel(contact_point[u_axis] / contact_point.w) else {
@@ -135,15 +135,15 @@ fn find_face_collision(
         if !voxel_is_solid(
             voxel_data,
             layout,
-            math::tuv_to_xyz(t_axis, [voxel_t, voxel_u, voxel_v]),
+            [voxel_t, voxel_u, voxel_v].tuv_to_xyz(t_axis),
         ) {
             continue;
         }
 
         // A collision was found. Update the hit.
         hit = Some(ChunkCastHit {
             tanh_distance: new_tanh_distance,
-            normal,
+            normal: normal.into(),
         });
     }
 
@@ -168,14 +168,14 @@ fn find_edge_collision(
     // Loop through all grid lines overlapping the bounding box
     for (u, v) in bounding_box.grid_lines(u_axis, v_axis) {
         // Compute vectors Lorentz-orthogonal to the edge and to each other
-        let edge_normal0 =
-            math::tuv_to_xyz(t_axis, MVector::new(0.0, 1.0, 0.0, layout.grid_to_dual(u)))
-                .normalized();
+        let edge_normal0 = MVector::new(0.0, 1.0, 0.0, layout.grid_to_dual(u))
+            .tuv_to_xyz(t_axis)
+            .normalized_direction();
 
-        let edge_normal1 =
-            math::tuv_to_xyz(t_axis, MVector::new(0.0, 0.0, 1.0, layout.grid_to_dual(v)));
-        let edge_normal1 =
-            (edge_normal1 - edge_normal0 * edge_normal0.mip(&edge_normal1)).normalized();
+        let edge_normal1 = MVector::new(0.0, 0.0, 1.0, layout.grid_to_dual(v)).tuv_to_xyz(t_axis);
+        let edge_normal1 = (*edge_normal1.as_ref()
+            - *edge_normal0.as_ref() * edge_normal0.mip(&edge_normal1))
+        .normalized_direction();
 
         let Some(new_tanh_distance) = ray.solve_sphere_line_intersection(
             &edge_normal0,
@@ -192,8 +192,8 @@ fn find_edge_collision(
 
         let ray_endpoint = ray.ray_point(new_tanh_distance);
         let contact_point = ray_endpoint
-            - edge_normal0 * ray_endpoint.mip(&edge_normal0)
-            - edge_normal1 * ray_endpoint.mip(&edge_normal1);
+            - edge_normal0.as_ref() * ray_endpoint.mip(&edge_normal0)
+            - edge_normal1.as_ref() * ray_endpoint.mip(&edge_normal1);
 
         // Compute the t-coordinate of the voxels at the contact point
         let Some(voxel_t) = layout.dual_to_voxel(contact_point[t_axis] / contact_point.w) else {
@@ -206,7 +206,7 @@ fn find_edge_collision(
                 !voxel_is_solid(
                     voxel_data,
                     layout,
-                    math::tuv_to_xyz(t_axis, [voxel_t, voxel_u, voxel_v]),
+                    [voxel_t, voxel_u, voxel_v].tuv_to_xyz(t_axis),
                 )
             })
         }) {
@@ -248,17 +248,19 @@ fn find_vertex_collision(
         }
 
         // Compute vectors Lorentz-orthogonal to the vertex and to each other
-        let vertex_normal0 = MVector::new(1.0, 0.0, 0.0, layout.grid_to_dual(x)).normalized();
+        let vertex_normal0 =
+            MVector::new(1.0, 0.0, 0.0, layout.grid_to_dual(x)).normalized_direction();
 
         let vertex_normal1 = MVector::new(0.0, 1.0, 0.0, layout.grid_to_dual(y));
-        let vertex_normal1 =
-            (vertex_normal1 - vertex_normal0 * vertex_normal0.mip(&vertex_normal1)).normalized();
+        let vertex_normal1 = (vertex_normal1
+            - vertex_normal0.as_ref() * vertex_normal0.mip(&vertex_normal1))
+        .normalized_direction();
 
         let vertex_normal2 = MVector::new(0.0, 0.0, 1.0, layout.grid_to_dual(z));
         let vertex_normal2 = (vertex_normal2
-            - vertex_normal0 * vertex_normal0.mip(&vertex_normal2)
-            - vertex_normal1 * vertex_normal1.mip(&vertex_normal2))
-        .normalized();
+            - vertex_normal0.as_ref() * vertex_normal0.mip(&vertex_normal2)
+            - vertex_normal1.as_ref() * vertex_normal1.mip(&vertex_normal2))
+        .normalized_direction();
 
         let Some(new_tanh_distance) = ray.solve_sphere_point_intersection(
             &vertex_normal0,
@@ -281,13 +283,13 @@ fn find_vertex_collision(
             layout.grid_to_dual(z),
             1.0,
         )
-        .normalized();
+        .normalized_point();
 
         // A collision was found. Update the hit.
         let ray_endpoint = ray.ray_point(new_tanh_distance);
         hit = Some(ChunkCastHit {
             tanh_distance: new_tanh_distance,
-            normal: ray_endpoint - vertex_position,
+            normal: ray_endpoint - vertex_position.as_ref(),
         });
     }
 
@@ -355,20 +357,21 @@ mod tests {
             ray_start_grid_coords[2] / ctx.layout.dual_to_grid_factor(),
             1.0,
         )
-        .normalized();
+        .normalized_point();
 
         let ray_end = MVector::new(
             ray_end_grid_coords[0] / ctx.layout.dual_to_grid_factor(),
             ray_end_grid_coords[1] / ctx.layout.dual_to_grid_factor(),
             ray_end_grid_coords[2] / ctx.layout.dual_to_grid_factor(),
             1.0,
         )
-        .normalized();
+        .normalized_point();
 
         let ray = Ray::new(
             ray_start,
-            ((ray_end - ray_start) + ray_start * ray_start.mip(&(ray_end - ray_start)))
-                .normalized(),
+            ((ray_end.as_ref() - ray_start.as_ref())
+                + ray_start.as_ref() * ray_start.mip(&(ray_end.as_ref() - ray_start.as_ref())))
+            .normalized_direction(),
         );
 
         let tanh_distance = (-ray_start.mip(&ray_end)).acosh();
@@ -511,12 +514,12 @@ mod tests {
         // The ray we care about is after its start point has moved to the contact point.
         let ray = MIsometry::translation(
             &ray.position,
-            &ray.ray_point(hit.tanh_distance).normalized(),
+            &ray.ray_point(hit.tanh_distance).normalized_point(),
         ) * ray;
 
         // Project normal to be perpendicular to the ray's position
-        let corrected_normal =
-            (hit.normal + ray.position * hit.normal.mip(&ray.position)).normalized();
+        let corrected_normal = (hit.normal + ray.position.as_ref() * hit.normal.mip(&ray.position))
+            .normalized_direction();
 
         // Check that the normal and ray are pointing opposite directions
         assert!(corrected_normal.mip(&ray.direction) < 0.0);

common/src/chunk_ray_casting.rs

@@ -1,7 +1,6 @@
 use crate::{
     collision_math::Ray,
-    math,
-    math::MVector,
+    math::{MVector, PermuteXYZ},
     node::{ChunkLayout, VoxelAABB, VoxelData},
     voxel_math::{CoordAxis, CoordSign, Coords},
     world::Material,
@@ -69,8 +68,9 @@ fn find_face_collision(
     for t in bounding_box.grid_planes(t_axis) {
         // Find a normal to the grid plane. Note that (t, 0, 0, x) is a normal of the plane whose closest point
         // to the origin is (x, 0, 0, t), and we use that fact here.
-        let normal = math::tuv_to_xyz(t_axis, MVector::new(1.0, 0.0, 0.0, layout.grid_to_dual(t)))
-            .normalized();
+        let normal = MVector::new(1.0, 0.0, 0.0, layout.grid_to_dual(t))
+            .tuv_to_xyz(t_axis)
+            .normalized_direction();
 
         let Some(new_tanh_distance) = ray.solve_point_plane_intersection(&normal) else {
             continue;
@@ -97,7 +97,7 @@ fn find_face_collision(
         };
 
         let ray_endpoint = ray.ray_point(new_tanh_distance);
-        let contact_point = ray_endpoint - normal * ray_endpoint.mip(&normal);
+        let contact_point = ray_endpoint - normal.as_ref() * ray_endpoint.mip(&normal);
 
         // Compute the u and v-coordinates of the voxels at the contact point
         let Some(voxel_u) = layout.dual_to_voxel(contact_point[u_axis] / contact_point.w) else {
@@ -111,15 +111,15 @@ fn find_face_collision(
         if !voxel_is_solid(
             voxel_data,
             layout,
-            math::tuv_to_xyz(t_axis, [voxel_t, voxel_u, voxel_v]),
+            [voxel_t, voxel_u, voxel_v].tuv_to_xyz(t_axis),
         ) {
             continue;
         }
 
         // A collision was found. Update the hit.
         hit = Some(ChunkCastHit {
             tanh_distance: new_tanh_distance,
-            voxel_coords: Coords(math::tuv_to_xyz(t_axis, [voxel_t, voxel_u, voxel_v])),
+            voxel_coords: Coords([voxel_t, voxel_u, voxel_v].tuv_to_xyz(t_axis)),
             face_axis: CoordAxis::try_from(t_axis).unwrap(),
             face_sign,
         });
@@ -186,20 +186,21 @@ mod tests {
             ray_start_grid_coords[2] / ctx.layout.dual_to_grid_factor(),
             1.0,
         )
-        .normalized();
+        .normalized_point();
 
         let ray_end = MVector::new(
             ray_end_grid_coords[0] / ctx.layout.dual_to_grid_factor(),
             ray_end_grid_coords[1] / ctx.layout.dual_to_grid_factor(),
             ray_end_grid_coords[2] / ctx.layout.dual_to_grid_factor(),
             1.0,
         )
-        .normalized();
+        .normalized_point();
 
         let ray = Ray::new(
             ray_start,
-            ((ray_end - ray_start) + ray_start * ray_start.mip(&(ray_end - ray_start)))
-                .normalized(),
+            ((ray_end.as_ref() - ray_start.as_ref())
+                + ray_start.as_ref() * ray_start.mip(&(ray_end.as_ref() - ray_start.as_ref())))
+            .normalized_direction(),
         );
 
         let tanh_distance = (-(ray_start.mip(&ray_end))).acosh();