Small rename/refactor

src/examples.rs

@@ -70,7 +70,7 @@ impl Barbs {
         }
     }
 
-    fn limit_check(&self, xform: &Transform, iters: usize) -> bool {
+    fn limit_check(&self, xform: &Transform, _: usize) -> bool {
         // Assume all scales are the same (for now)
         let (s, _, _) = xform.get_scale();
         return s < 0.005;
@@ -113,7 +113,7 @@ impl Barbs {
     }
 }
 
-pub struct RamHorn {
+pub struct TreeThing {
     incr: Transform,
     splits: [Transform; 4],
     base: Vec<Vertex>,
@@ -123,12 +123,12 @@ pub struct RamHorn {
     depth: usize,
 }
 
-impl RamHorn {
+impl TreeThing {
-    pub fn new(f: f32, depth: usize) -> RamHorn {
+    pub fn new(f: f32, depth: usize) -> TreeThing {
         // Incremental transform for each layer:
         let v = Unit::new_normalize(Vector3::new(-1.0, 0.0, 1.0));
         let incr: Transform = Transform::new().
-            translate(0.0, 0.0, 0.8 * f).
+            translate(0.0, 0.0, 0.9 * f).
             rotate(&v, 0.4 * f).
             scale(1.0 - (1.0 - 0.95) * f);
         // 'Base' vertices, used throughout:
@@ -158,7 +158,7 @@ impl RamHorn {
                 translate(0.25, 0.25, 0.0).
                 scale(0.5);
         }
-        RamHorn {
+        TreeThing {
             incr: incr,
             splits: splits,
             base: base,
@@ -171,10 +171,9 @@ impl RamHorn {
 
     pub fn run(mut self) -> Mesh {
         // Make seed vertices, use them for 'bottom' face, and recurse:
-        let xf = id().translate(0.0, 0.0, -0.5);
+        self.verts.append(&mut self.base.clone());
-        self.verts.append(&mut xf.transform(&self.base));
         self.faces.extend_from_slice(&[0, 1, 2,   0, 2, 3]);
-        self.trans(id(), [0,1,2,3]);
+        self.child(id(), self.depth, [0,1,2,3]);
         return Mesh {
             verts: self.verts,
             faces: self.faces,
@@ -184,12 +183,26 @@ impl RamHorn {
     fn limit_check(&self, xform: &Transform) -> bool {
         // Assume all scales are the same (for now)
         let (s, _, _) = xform.get_scale();
-        return s < 0.005;
+        return s < 0.002;
     }
 
-    // 'Transition' stage (which splits from base to 4 parts):
+    fn child(&mut self, xform: Transform, depth: usize, b: [usize; 4]) {
-    fn trans(&mut self, xform: Transform, b: [usize; 4]) {
 
+        if self.limit_check(&xform) {
+            self.faces.extend_from_slice(&[b[0], b[2], b[1], b[0], b[3], b[2]]);
+            return;
+        }
+
+        if depth > 0 {
+            // Just recurse on the current path:
+            let xform2 = xform * self.incr;
+            let (n0, n1) = self.verts.append_indexed(xform2.transform(&self.base));
+            self.faces.append(&mut util::parallel_zigzag2(n0..n1, b.to_vec()));
+
+            self.child(xform2, depth - 1, [n0, n0 + 1, n0 + 2, n0 + 3]);
+
+        } else {
+            // 'Transition' stage (splits to 4 parts):
             let (n, _) = self.verts.append_indexed(xform.transform(&self.base));
             let (m01, _) = self.verts.append_indexed(xform.transform(&self.trans));
             let (m12, m23, m30, c) = (m01 + 1, m01 + 2, m01 + 3, m01 + 4);
@@ -218,23 +231,6 @@ impl RamHorn {
             self.child(xform * self.splits[2], self.depth,[c, m30, n+0, m01]);
             self.child(xform * self.splits[3], self.depth,[c, m23, n+3, m30]);
         }
-
-    fn child(&mut self, xform: Transform, depth: usize, b: [usize; 4]) {
-
-        if self.limit_check(&xform) {
-            self.faces.extend_from_slice(&[b[0], b[2], b[1], b[0], b[3], b[2]]);
-            return;
-        }
-
-        if depth <= 0 {
-            self.trans(xform, b);
-        } else {
-            let xform2 = xform * self.incr;
-            let (n0, n1) = self.verts.append_indexed(xform2.transform(&self.base));
-            self.faces.append(&mut util::parallel_zigzag2(n0..n1, b.to_vec()));
-
-            self.child(xform2, depth - 1, [n0, n0 + 1, n0 + 2, n0 + 3]);
-        }
     }
 }
 

src/lib.rs

@@ -84,10 +84,10 @@ mod tests {
     }
 
     #[test]
-    fn ramhorn_branch() {
+    fn tree_thing() {
-        let name = "ramhorn_branch";
+        let name = "tree_thing";
         println!("---------------------------------------------------");
-        let b = examples::RamHorn::new(0.6, 12);
+        let b = examples::TreeThing::new(0.6, 10);
         let m = b.run();
 
         println!("Got {} verts...", m.verts.len());