swiftcoder
diff --git a/‎Cargo.toml
Lines changed: 3 additions & 2 deletions b/‎Cargo.toml
Lines changed: 3 additions & 2 deletions
diff --git a/‎README.md
Lines changed: 7 additions & 4 deletions b/‎README.md
Lines changed: 7 additions & 4 deletions
diff --git a/‎examples/common/mod.rs
Lines changed: 4 additions & 5 deletions b/‎examples/common/mod.rs
Lines changed: 4 additions & 5 deletions
diff --git a/‎examples/common/sources.rs
Lines changed: 53 additions & 7 deletions b/‎examples/common/sources.rs
Lines changed: 53 additions & 7 deletions
diff --git a/‎examples/common/text.rs
Lines changed: 26 additions & 0 deletions b/‎examples/common/text.rs
Lines changed: 26 additions & 0 deletions
@@ -1,14 +1,15 @@
 [package]
 name = "isosurface"
-version = "0.0.3"
+version = "0.0.4"
 authors = ["Tristam MacDonald <swiftcoder@gmail.com>"]
 license = "Apache-2.0"
 description = "Isosurface extraction algorithms"
 repository = "https://github.com/swiftcoder/isosurface"
 readme = "README.md"
 
 [dev-dependencies]
-glium = "0.18.0"
+glium = "0.17.0"
+glium_text_rusttype = "0.2.0"
 cgmath = "0.15.0"
 
 [profile.dev]
 
@@ -1,15 +1,18 @@
 # Isosurface
-Isosurface extraction algorithms for Rust. Currently only a few techniques are implemented, fancier algorithms to be added at a later date.
+Isosurface extraction algorithms for Rust. Currently only a few techniques are implemented.
 
-This crate has no dependencies, although the example relies on the glium, cgmath, num crates.
+This crate intentionally has no dependencies to keep the footprint of the library small. The examples rely on the `glium`, `glium_text_rusttype`, and `cgmath` crates.
 
 # Marching Cubes
-The Marching Cubes implementation produces perfectly indexed meshes with no duplicate vertices, through the use of a (fairly involved) index caching system. The complexity of the cache could no doubt be reduced through some clever arithmetic, but it is not currently a bottleneck.
+The Marching Cubes implementation produces perfectly indexed meshes with few duplicate vertices, through the use of a (fairly involved) index caching system. The complexity of the cache could no doubt be reduced through some clever arithmetic, but it is not currently a bottleneck.
 
 The implementation has been optimised for performance, with memory use kept as a low as possible considering. For an NxNxN voxel chunk, it will allocate roughly NxN of f32 storage for isosurface values, and Nx(N+1) of u32 storage for the index cache.
 
-Indices are 32-bit becuase for chunks of 32x32 and larger you'll typically end up with mor than 65k vertices. If you are targetting a mobile platform that supports only 16-bit indices, you'll need to use smaller chunk sizes, and truncate on the output side.
+Indices are 32-bit because for chunks of 32x32 and larger you'll typically end up with more than 65k vertices. If you are targeting a mobile platform that supports only 16-bit indices, you'll need to use smaller chunk sizes, and truncate on the output side.
 
+# Linear Hashed Marching Cubes
+A very efficient algorithm using interleaved integer coordinates to represent octree cells, and storing them in a hash table. Results in better mesh quality than regular marching cubes, and is significantly faster. Memory usage is less predictable, but shouldn't be significantly higher than standard marching cubes.
+ 
 # Point Clouds and Deferred Rasterisation
 Point cloud extraction is typically not all that useful, given that point clouds don't contain any data about the actual surface. However, Gavan Woolery (gavanw@) posted an interesting image of reconstructing surface data in image space on the GPU, so I've added a simple example of that.  
 
 
@@ -1,4 +1,4 @@
-// Copyright 2017 Tristam MacDonald
+// Copyright 2018 Tristam MacDonald
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 pub mod sources;
+pub mod text;
 
 use std::slice;
 use std::mem;
@@ -21,10 +22,8 @@ use std::mem;
 /// copying. It is optimal, but it is also punching holes in the type system. I hope that Rust
 /// provides safe functionality to handle this in the future. In the meantime, reproduce
 /// this workaround at your own risk.
-pub fn reinterpret_cast_slice<S, T>(input : &[S]) -> &[T] {
+pub fn reinterpret_cast_slice<S, T>(input: &[S]) -> &[T] {
     let length_in_bytes = input.len() * mem::size_of::<S>();
     let desired_length = length_in_bytes / mem::size_of::<T>();
-    unsafe {
-        slice::from_raw_parts(input.as_ptr() as *const T, desired_length)
-    }
+    unsafe { slice::from_raw_parts(input.as_ptr() as *const T, desired_length) }
 }
@@ -1,4 +1,4 @@
-// Copyright 2017 Tristam MacDonald
+// Copyright 2018 Tristam MacDonald
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -17,18 +17,64 @@
 use isosurface::source::Source;
 
 /// The distance-field equation for a torus
-fn torus(x : f32, y : f32, z : f32) -> f32 {
-    const R1 : f32 = 1.0 / 4.0;
-    const R2 : f32 = 1.0 / 10.0;
-    let q_x = ((x*x + y*y).sqrt()).abs() - R1;
-    let len = (q_x*q_x + z*z).sqrt();
+fn torus(x: f32, y: f32, z: f32) -> f32 {
+    const R1: f32 = 1.0 / 4.0;
+    const R2: f32 = 1.0 / 10.0;
+    let q_x = ((x * x + y * y).sqrt()).abs() - R1;
+    let len = (q_x * q_x + z * z).sqrt();
     len - R2
 }
 
 pub struct Torus {}
 
 impl Source for Torus {
-    fn sample(&self, x : f32, y : f32, z : f32) -> f32 {
+    fn sample(&self, x: f32, y: f32, z: f32) -> f32 {
         torus(x - 0.5, y - 0.5, z - 0.5)
     }
 }
+
+fn abs(x: f32, y: f32, z: f32) -> (f32, f32, f32) {
+    (
+        if x > 0.0 { x } else { -x },
+        if y > 0.0 { y } else { -y },
+        if z > 0.0 { z } else { -z },
+    )
+}
+
+fn max(px: f32, py: f32, pz: f32, qx: f32, qy: f32, qz: f32) -> (f32, f32, f32) {
+    (
+        if px > qx { px } else { qx },
+        if py > qy { py } else { qy },
+        if pz > qz { pz } else { qz },
+    )
+}
+
+/// The distance field equation for a cube
+fn cube(px: f32, py: f32, pz: f32, bx: f32, by: f32, bz: f32) -> f32 {
+    let (ax, ay, az) = abs(px, py, pz);
+    let (dx, dy, dz) = (ax - bx, ay - by, az - bz);
+    let (mx, my, mz) = max(dx, dy, dz, 0.0, 0.0, 0.0);
+    let l = (mx * mx + my * my + mz * mz).sqrt();
+    dx.max(dz.max(dy)).min(0.0) + l
+}
+
+/// The distance field equation for a sphere
+fn sphere(x: f32, y: f32, z: f32, r: f32) -> f32 {
+    (x * x + y * y + z * z).sqrt() - r
+}
+
+/// Subtract one distance field from another (i.e. CSG difference operation)
+fn subtract(d1: f32, d2: f32) -> f32 {
+    d2.max(-d1)
+}
+
+pub struct CubeSphere {}
+
+impl Source for CubeSphere {
+    fn sample(&self, x: f32, y: f32, z: f32) -> f32 {
+        subtract(
+            sphere(x - 0.5, y - 0.5, z - 0.5, 0.25),
+            cube(x - 0.5, y - 0.5, z - 0.5, 0.2, 0.2, 0.2),
+        )
+    }
+}
@@ -0,0 +1,26 @@
+// Copyright 2018 Tristam MacDonald
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Conveniences to make the `glium_text` API easier to use in samples.
+
+use cgmath::{Matrix4, Vector3};
+
+/// Produce a transform matrix that will display text at offset column `x`, row `y`, in a
+/// display-filling coordinate space N characters wide and N*aspect rows high.
+pub fn layout_text(characters_per_row: f32, aspect: f32, x: f32, y: f32) -> Matrix4<f32> {
+    let inv_scale = 2.0 / characters_per_row;
+    Matrix4::from_translation(Vector3::new(-1.0, -1.0, 0.0))
+        * Matrix4::from_nonuniform_scale(inv_scale, inv_scale * aspect, 1.0)
+        * Matrix4::from_translation(Vector3::new(x, y, 0.0))
+}