Document and simplify math module

Author: patowen

client/src/graphics/draw.rs

@@ -289,7 +289,7 @@ impl Draw {
         let draw_started = Instant::now();
         let view = sim.as_ref().map_or_else(Position::origin, |sim| sim.view());
         let projection = frustum.projection(1.0e-4);
-        let view_projection = projection.matrix() * na::Matrix4::from(view.local.mtranspose());
+        let view_projection = projection.matrix() * na::Matrix4::from(view.local.inverse());
         self.loader.drive();
 
         let device = &*self.gfx.device;

client/src/graphics/frustum.rs

@@ -93,7 +93,8 @@ impl FrustumPlanes {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use common::math::translate_along;
+
+    use common::math::MIsometry;
     use std::f32;
 
     #[test]
@@ -102,28 +103,27 @@ mod tests {
         let planes = Frustum::from_vfov(f32::consts::FRAC_PI_4, 1.0).planes();
         assert!(planes.contain(&MVector::origin(), 0.1));
         assert!(planes.contain(
-            &(translate_along(&-na::Vector3::z()) * MVector::origin()),
+            &(MIsometry::translation_along(&-na::Vector3::z()) * MVector::origin()),
             0.0
         ));
         assert!(!planes.contain(
-            &(translate_along(&na::Vector3::z()) * MVector::origin()),
+            &(MIsometry::translation_along(&na::Vector3::z()) * MVector::origin()),
             0.0
         ));
-
         assert!(!planes.contain(
-            &(translate_along(&na::Vector3::x()) * MVector::origin()),
+            &(MIsometry::translation_along(&na::Vector3::x()) * MVector::origin()),
             0.0
         ));
         assert!(!planes.contain(
-            &(translate_along(&na::Vector3::y()) * MVector::origin()),
+            &(MIsometry::translation_along(&na::Vector3::y()) * MVector::origin()),
             0.0
         ));
         assert!(!planes.contain(
-            &(translate_along(&-na::Vector3::x()) * MVector::origin()),
+            &(MIsometry::translation_along(&-na::Vector3::x()) * MVector::origin()),
             0.0
         ));
         assert!(!planes.contain(
-            &(translate_along(&-na::Vector3::y()) * MVector::origin()),
+            &(MIsometry::translation_along(&-na::Vector3::y()) * MVector::origin()),
             0.0
         ));
     }

client/src/graphics/voxels/mod.rs

@@ -122,7 +122,7 @@ impl Voxels {
         }
         let node_scan_started = Instant::now();
         let frustum_planes = frustum.planes();
-        let local_to_view = view.local.mtranspose();
+        let local_to_view = view.local.inverse();
         let mut extractions = Vec::new();
         let mut workqueue_is_full = false;
         for &(node, ref node_transform) in nearby_nodes {

client/src/local_character_controller.rs

@@ -25,8 +25,7 @@ impl LocalCharacterController {
     pub fn oriented_position(&self) -> Position {
         Position {
             node: self.position.node,
-            local: self.position.local
-                * MIsometry::unit_quaternion_to_homogeneous(self.orientation),
+            local: self.position.local * MIsometry::from(self.orientation),
         }
     }
 

client/src/sim.rs

@@ -11,7 +11,7 @@ use common::{
     character_controller,
     collision_math::Ray,
     graph::{Graph, NodeId},
-    graph_ray_casting, math,
+    graph_ray_casting,
     math::{MIsometry, MVector},
     node::{populate_fresh_nodes, ChunkId, VoxelData},
     proto::{
@@ -510,8 +510,9 @@ impl Sim {
     pub fn view(&self) -> Position {
         let mut pos = self.local_character_controller.oriented_position();
         let up = self.graph.get_relative_up(&pos).unwrap();
-        pos.local *=
-            math::translate_along(&(up.as_ref() * (self.cfg.character.character_radius - 1e-3)));
+        pos.local *= MIsometry::translation_along(
+            &(up.as_ref() * (self.cfg.character.character_radius - 1e-3)),
+        );
         pos
     }
 

common/src/character_controller/collision.rs

@@ -5,7 +5,7 @@ use tracing::error;
 use crate::{
     collision_math::Ray,
     graph::Graph,
-    graph_collision, math,
+    graph_collision,
     math::{MIsometry, MVector},
     proto::Position,
 };
@@ -56,7 +56,7 @@ pub fn check_collision(
         .atanh();
 
     let displacement_vector = displacement_normalized.xyz() * distance;
-    let displacement_transform = math::translate_along(&displacement_vector);
+    let displacement_transform = MIsometry::translation_along(&displacement_vector);
 
     CollisionCheckingResult {
         displacement_vector,
@@ -67,7 +67,7 @@ pub fn check_collision(
             // This normal now represents a contact point at the origin, so we omit the w-coordinate
             // to ensure that it's orthogonal to the origin.
             normal: na::UnitVector3::new_normalize(
-                (displacement_transform.mtranspose() * hit.normal).xyz(),
+                (displacement_transform.inverse() * hit.normal).xyz(),
             ),
         }),
     }

common/src/character_controller/mod.rs

@@ -11,7 +11,7 @@ use crate::{
         vector_bounds::{BoundedVectors, VectorBound},
     },
     graph::Graph,
-    math,
+    math::{self, MIsometry},
     proto::{CharacterInput, Position},
     sanitize_motion_input,
     sim_config::CharacterConfig,
@@ -47,7 +47,7 @@ pub fn run_character_step(
     }
 
     // Renormalize
-    position.local = position.local.renormalize_isometry();
+    position.local = position.local.renormalized();
     let (next_node, transition_xf) = graph.normalize_transform(position.node, &position.local);
     if next_node != position.node {
         position.node = next_node;
@@ -120,7 +120,7 @@ fn run_no_clip_character_step(
 ) {
     *velocity = ctx.movement_input * ctx.cfg.no_clip_movement_speed;
     *on_ground = false;
-    position.local *= math::translate_along(&(*velocity * ctx.dt_seconds));
+    position.local *= MIsometry::translation_along(&(*velocity * ctx.dt_seconds));
 }
 
 /// Returns the normal corresponding to the ground below the character, up to the `allowed_distance`. If

common/src/chunk_collision.rs

@@ -92,7 +92,7 @@ fn find_face_collision(
         // 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)))
-            .lorentz_normalize();
+            .normalized();
 
         let Some(new_tanh_distance) =
             ray.solve_sphere_plane_intersection(&normal, collider_radius.sinh())
@@ -170,12 +170,12 @@ fn find_edge_collision(
         // 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)))
-                .lorentz_normalize();
+                .normalized();
 
         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)).lorentz_normalize();
+            (edge_normal1 - edge_normal0 * edge_normal0.mip(&edge_normal1)).normalized();
 
         let Some(new_tanh_distance) = ray.solve_sphere_line_intersection(
             &edge_normal0,
@@ -248,19 +248,17 @@ 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)).lorentz_normalize();
+        let vertex_normal0 = MVector::new(1.0, 0.0, 0.0, layout.grid_to_dual(x)).normalized();
 
         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))
-        .lorentz_normalize();
+        let vertex_normal1 =
+            (vertex_normal1 - vertex_normal0 * vertex_normal0.mip(&vertex_normal1)).normalized();
 
         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))
-        .lorentz_normalize();
+        .normalized();
 
         let Some(new_tanh_distance) = ray.solve_sphere_point_intersection(
             &vertex_normal0,
@@ -283,7 +281,7 @@ fn find_vertex_collision(
             layout.grid_to_dual(z),
             1.0,
         )
-        .lorentz_normalize();
+        .normalized();
 
         // A collision was found. Update the hit.
         let ray_endpoint = ray.ray_point(new_tanh_distance);
@@ -306,7 +304,7 @@ fn voxel_is_solid(voxel_data: &VoxelData, layout: &ChunkLayout, coords: [u8; 3])
 
 #[cfg(test)]
 mod tests {
-    use crate::node::VoxelData;
+    use crate::{math::MIsometry, node::VoxelData};
 
     use super::*;
 
@@ -357,20 +355,20 @@ mod tests {
             ray_start_grid_coords[2] / ctx.layout.dual_to_grid_factor(),
             1.0,
         )
-        .lorentz_normalize();
+        .normalized();
 
         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,
         )
-        .lorentz_normalize();
+        .normalized();
 
         let ray = Ray::new(
             ray_start,
             ((ray_end - ray_start) + ray_start * ray_start.mip(&(ray_end - ray_start)))
-                .lorentz_normalize(),
+                .normalized(),
         );
 
         let tanh_distance = (-ray_start.mip(&ray_end)).acosh();
@@ -511,14 +509,14 @@ mod tests {
     /// Ensures that the normal is pointing outward, opposite the ray direction.
     fn sanity_check_normal(ray: &Ray, hit: &ChunkCastHit) {
         // The ray we care about is after its start point has moved to the contact point.
-        let ray = math::translate(
+        let ray = MIsometry::translation(
             &ray.position,
-            &ray.ray_point(hit.tanh_distance).lorentz_normalize(),
+            &ray.ray_point(hit.tanh_distance).normalized(),
         ) * ray;
 
         // Project normal to be perpendicular to the ray's position
         let corrected_normal =
-            (hit.normal + ray.position * hit.normal.mip(&ray.position)).lorentz_normalize();
+            (hit.normal + ray.position * hit.normal.mip(&ray.position)).normalized();
 
         // Check that the normal and ray are pointing opposite directions
         assert!(corrected_normal.mip(&ray.direction) < 0.0);

common/src/chunk_ray_casting.rs

@@ -70,7 +70,7 @@ fn find_face_collision(
         // 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)))
-            .lorentz_normalize();
+            .normalized();
 
         let Some(new_tanh_distance) = ray.solve_point_plane_intersection(&normal) else {
             continue;
@@ -186,20 +186,20 @@ mod tests {
             ray_start_grid_coords[2] / ctx.layout.dual_to_grid_factor(),
             1.0,
         )
-        .lorentz_normalize();
+        .normalized();
 
         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,
         )
-        .lorentz_normalize();
+        .normalized();
 
         let ray = Ray::new(
             ray_start,
             ((ray_end - ray_start) + ray_start * ray_start.mip(&(ray_end - ray_start)))
-                .lorentz_normalize(),
+                .normalized(),
         );
 
         let tanh_distance = (-(ray_start.mip(&ray_end))).acosh();