Initial checkpoint.

The system is capable of parsing it's command
line, and of generating a mesh representing
the mushroom's stalk.

src/render.rs

@@ -0,0 +1,233 @@
+use stl_io::{self, Normal, Triangle, Vertex};
+
+fn new_triangle(p1: &Vertex, p2: &Vertex, p3: &Vertex) -> stl_io::Triangle {
+    // Set Vector U to (Triangle.p2 minus Triangle.p1)
+    // Set Vector V to (Triangle.p3 minus Triangle.p1)
+
+    // Set Normal.x to (multiply U.y by V.z) minus (multiply U.z by V.y)
+    // Set Normal.y to (multiply U.z by V.x) minus (multiply U.x by V.z)
+    // Set Normal.z to (multiply U.x by V.y) minus (multiply U.y by V.x)
+
+    let u = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
+    let v = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
+
+    let n_x = (u[1] * v[2]) - (u[2] * v[1]);
+    let n_y = (u[2] * v[0]) - (u[0] * v[2]);
+    let n_z = (u[0] * v[1]) - (u[1] * v[0]);
+
+    stl_io::Triangle {
+        normal: Normal::new([n_x, n_y, n_z]),
+        vertices: [p1.clone(), p2.clone(), p3.clone()],
+    }
+}
+
+/// N steps around a circle, measured in radians.
+fn radian_steps(steps: u32) -> Vec<f32> {
+    let counter = 0..steps;
+    let stepsize = std::f64::consts::TAU / steps as f64;
+
+    return counter.map(|i| (i as f64 * stepsize) as f32).collect();
+}
+
+/// Find a point on the cirle at a given angle (in radians).
+fn vertex_on_circle(center: &Vertex, radius: f32, angle: f32) -> Vertex {
+    let x = center[0] + (radius * angle.cos());
+    let y = center[1] + (radius * angle.sin());
+    let z = center[2];
+
+    return Vertex::new([x, y, z]);
+}
+
+fn vertexes_on_circle(center: &Vertex, radius: f32, steps: u32) -> Vec<Vertex> {
+    return radian_steps(steps)
+        .iter()
+        .map(|angle| vertex_on_circle(center, radius, *angle))
+        .collect();
+}
+
+fn tube_base(center: &Vertex, edge: &Vec<Vertex>) -> Vec<Triangle> {
+    let mut result = Vec::with_capacity(edge.len());
+
+    for i in 0..edge.len() {
+        result.push(new_triangle(&center, &edge[(i + 1) % edge.len()], &edge[i]));
+    }
+
+    return result;
+}
+
+fn tube_sides(botoom_edge: &Vec<Vertex>, top_edge: &Vec<Vertex>) -> Vec<Triangle> {
+    assert_eq!(botoom_edge.len(), top_edge.len());
+
+    let mut result = Vec::with_capacity(2 * botoom_edge.len());
+
+    for i in 0..botoom_edge.len() {
+        let j = (i + 1) % botoom_edge.len();
+
+        result.push(new_triangle(&botoom_edge[i], &top_edge[j], &top_edge[i]));
+        result.push(new_triangle(&botoom_edge[i], &botoom_edge[j], &top_edge[j]));
+    }
+
+    return result;
+}
+
+fn tube_top(center: &Vertex, edge: &Vec<Vertex>) -> Vec<Triangle> {
+    // The top is the same, except the normals are reversed. We can do that by reversing the order of the vertexes.
+    let mut edge = edge.clone();
+    edge.reverse();
+
+    return tube_base(&center, &edge);
+}
+
+pub fn cylinder(height: f32, radius: f32, steps: u32) -> Vec<Triangle> {
+    let base_center = Vertex::new([0.0, 0.0, 0.0]);
+    let base_edge = vertexes_on_circle(&base_center, radius, steps);
+    let top_center = Vertex::new([0.0, 0.0, height]);
+    let top_edge = vertexes_on_circle(&top_center, radius, steps);
+
+    let mut result = Vec::new();
+
+    result.append(&mut tube_base(&base_center, &base_edge));
+    result.append(&mut tube_sides(&base_edge, &top_edge));
+    result.append(&mut tube_top(&top_center, &top_edge));
+
+    return result;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn new_triangle_normal() {
+        // Simple triangle
+        let a = Vertex::new([1.0, 0.0, 0.0]);
+        let b = Vertex::new([0.0, 1.0, 0.0]);
+        let c = Vertex::new([-1.0, 0.0, 0.0]);
+
+        let tri = new_triangle(&a, &b, &c);
+
+        assert_eq!(tri.normal, Normal::new([0.0, 0.0, 2.0]));
+
+        // Same triangle, reverse order.
+        let tri = new_triangle(&c, &b, &a);
+
+        assert_eq!(tri.normal, Normal::new([0.0, 0.0, -2.0]));
+
+        // Uneven numbers.
+        let a = Vertex::new([2.0, 0.0, 0.0]);
+        let b = Vertex::new([0.0, 3.0, 0.0]);
+        let c = Vertex::new([-4.0, 0.0, 0.0]);
+
+        let tri_big = new_triangle(&a, &b, &c);
+
+        assert_eq!(tri_big.normal, Normal::new([0.0, 0.0, 18.0]));
+    }
+
+    #[test]
+    fn radian_steps_basic() {
+        assert_eq!(radian_steps(0), []);
+        assert_eq!(radian_steps(1), [0.0]);
+        assert_eq!(radian_steps(2), [0.0, std::f32::consts::PI]);
+        assert_eq!(
+            radian_steps(3),
+            [
+                0.0,
+                std::f32::consts::PI * 2.0 / 3.0,
+                std::f32::consts::PI * 4.0 / 3.0
+            ]
+        );
+        assert_eq!(
+            radian_steps(4),
+            [
+                0.0,
+                std::f32::consts::PI * 0.5,
+                std::f32::consts::PI,
+                std::f32::consts::PI * 1.5,
+            ]
+        );
+    }
+
+    fn validate_vec_vertex_relative_eq(val: &Vec<Vertex>, expected: &Vec<Vertex>) {
+        let mut pass = true;
+
+        if val.len() != expected.len() {
+            pass = false;
+        }
+
+        for i in 0..val.len() {
+            for j in 0..3 {
+                if !relative_eq!(val[i][j], expected[i][j]) {
+                    pass = false;
+                }
+            }
+        }
+
+        if !pass {
+            // We re-compare here (which will always fail) to get the friendly error message,
+            // which I can't figure out how to generate directly.
+            assert_eq!(val, expected);
+        }
+    }
+
+    #[test]
+    fn vertexes_on_circle_basic() {
+        let val = vertexes_on_circle(&Vertex::new([0.0, 0.0, 0.0]), 1.0, 4);
+
+        let expected = [
+            Vertex::new([1.0, 0.0, 0.0]),
+            Vertex::new([0.0, 1.0, 0.0]),
+            Vertex::new([-1.0, 0.0, 0.0]),
+            Vertex::new([0.0, -1.0, 0.0]),
+        ]
+        .to_vec();
+
+        validate_vec_vertex_relative_eq(&val, &expected);
+    }
+
+    #[test]
+    fn vertexes_on_circle_complex() {
+        let val = vertexes_on_circle(&Vertex::new([4.0, 5.0, 6.0]), 3.0, 4);
+
+        let expected = [
+            Vertex::new([7.0, 5.0, 6.0]),
+            Vertex::new([4.0, 8.0, 6.0]),
+            Vertex::new([1.0, 5.0, 6.0]),
+            Vertex::new([4.0, 2.0, 6.0]),
+        ]
+        .to_vec();
+
+        validate_vec_vertex_relative_eq(&val, &expected);
+    }
+
+    #[test]
+    fn tube_base_test() {
+        // fn tube_base(center: &Vertex, edge: &Vec<Vertex>) -> Vec<Triangle> {
+
+        let center = Vertex::new([0.0, 0.0, 0.0]);
+        let edge = vertexes_on_circle(&center, 1.0, 4);
+
+        let triangles = tube_base(&center, &edge);
+
+        assert_eq!(triangles.len(), edge.len());
+
+        for t in triangles {
+            // All of these triangles should have the same normal (down).
+            assert_eq!(t.normal, Vertex::new([0.0, 0.0, -1.0]));
+        }
+    }
+
+    #[test]
+    fn tube_top_test() {
+        let center = Vertex::new([0.0, 0.0, 0.0]);
+        let edge = vertexes_on_circle(&center, 1.0, 4);
+
+        let triangles = tube_top(&center, &edge);
+
+        assert_eq!(triangles.len(), edge.len());
+
+        for t in triangles {
+            // All of these triangles should have the same normal (up).
+            assert_eq!(t.normal, Vertex::new([0.0, 0.0, 1.0]));
+        }
+    }
+}