Add support for evaluating max-norm distance fields

swiftcoder · swiftcoder · commit 82fed2e1bfb6 · 2021-01-18T09:07:00.000+01:00
diff --git a/src/linear_hashed_marching_cubes.rs b/src/linear_hashed_marching_cubes.rs
@@ -17,7 +17,7 @@ use crate::marching_cubes_impl::{get_offset, interpolate, march_cube};
 use crate::marching_cubes_tables::EDGE_CONNECTION;
 use crate::math::Vec3;
 use crate::morton::Morton;
-use crate::source::{HermiteSource, Source};
+use crate::source::{HermiteSource, Norm, Source};
 use std::collections::HashMap;
 
 // Morton cube corners are ordered differently to the marching cubes tables, so remap them to match.
@@ -43,15 +43,29 @@ impl Edge {
 /// Extracts meshes from distance fields using marching cubes over a linear hashed octree.
 pub struct LinearHashedMarchingCubes {
     max_depth: usize,
+    norm: Norm,
 }
 
 impl LinearHashedMarchingCubes {
     /// Create a new LinearHashedMarchingCubes.
     ///
     /// The depth of the internal octree will be at most `max_depth`, causing the tree to span the
-    /// equivalent of a cubic grid at most `2.pow(max_depth)` in either direction.
+    /// equivalent of a cubic grid at most `2.pow(max_depth)` in either direction. Distances
+    /// will be evaluated in Euclidean space.
     pub fn new(max_depth: usize) -> Self {
-        Self { max_depth }
+        Self {
+            max_depth,
+            norm: Norm::Euclidean,
+        }
+    }
+
+    /// Create a new LinearHashedMarchingCubes.
+    ///
+    /// The depth of the internal octree will be at most `max_depth`, causing the tree to span the
+    /// equivalent of a cubic grid at most `2.pow(max_depth)` in either direction. Distances will
+    /// be evaluated in accordance with the provided Norm.
+    pub fn with_norm(max_depth: usize, norm: Norm) -> Self {
+        Self { max_depth, norm }
     }
 
     /// Extracts a mesh from the given [`Source`](../source/trait.Source.html).
@@ -119,6 +133,13 @@ impl LinearHashedMarchingCubes {
         self.extract_surface(&octree, &primal_vertices, indices, &mut base_index, extract);
     }
 
+    fn diagonal(&self, distance: f32) -> f32 {
+        match self.norm {
+            Norm::Euclidean => distance * SQRT_OF_3,
+            Norm::Max => distance,
+        }
+    }
+
     fn build_octree<S>(&mut self, source: &S) -> LinearHashedOctree<f32>
     where
         S: Source,
@@ -130,7 +151,7 @@ impl LinearHashedMarchingCubes {
             |key: Morton, distance: &f32| {
                 let level = key.level();
                 let size = key.size();
-                level < 2 || (level < max_depth && distance.abs() <= size * SQRT_OF_3)
+                level < 2 || (level < max_depth && distance.abs() <= self.diagonal(size))
             },
             |key: Morton| {
                 let p = key.center();
diff --git a/src/source.rs b/src/source.rs
@@ -14,11 +14,19 @@
 
 use crate::math::Vec3;
 
+/// The context in which signed distance fields should be evaluated
+pub enum Norm {
+    /// The L^2 or Euclidean norm is the one you are used to, i.e. where l = sqrt(x^2 + y^2 + z^2).
+    Euclidean,
+    /// The L^∞ or Max norm represents Manhattan/Taxicab distance, i.e. l = max(|x|, |y|, |z|).
+    Max,
+}
+
 /// A source capable of sampling a signed distance field at discrete coordinates.
 pub trait Source {
     /// Samples the distance field at the given (x, y, z) coordinates.
     ///
-    /// Must return the signed distance (i.e. negative for coodinates inside the surface),
+    /// Must return the signed distance (i.e. negative for coordinates inside the surface),
     /// as our Marching Cubes implementation will evaluate the surface at the zero-crossing.
     fn sample(&self, x: f32, y: f32, z: f32) -> f32;
 }
