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,39 +183,7 @@ 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 trans(&mut self, xform: Transform, b: [usize; 4]) {
-
-        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);
-        self.faces.extend_from_slice(&[
-            // two faces straddling edge from vertex 0:
-            b[0], n+0, m01,
-            b[0], m30, n+0,
-            // two faces straddling edge from vertex 1:
-            b[1], n+1, m12,
-            b[1], m01, n+1,
-            // two faces straddling edge from vertex 2:
-            b[2], n+2, m23,
-            b[2], m12, n+2,
-            // two faces straddling edge from vertex 3:
-            b[3], n+3, m30,
-            b[3], m23, n+3,
-            // four faces from edge (0,1), (1,2), (2,3), (3,0):
-            b[0], m01, b[1],
-            b[1], m12, b[2],
-            b[2], m23, b[3],
-            b[3], m30, b[0],
-        ]);
-
-        self.child(xform * self.splits[0], self.depth,[c, m12, n+2, m23]);
-        self.child(xform * self.splits[1], self.depth,[c, m01, n+1, m12]);
-        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]) {
@@ -226,14 +193,43 @@ impl RamHorn {
             return;
         }
 
-        if depth <= 0 {
+        if depth > 0 {
-            self.trans(xform, b);
+            // Just recurse on the current path:
-        } 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]);
+
+        } 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);
+            self.faces.extend_from_slice(&[
+                // two faces straddling edge from vertex 0:
+                b[0], n+0, m01,
+                b[0], m30, n+0,
+                // two faces straddling edge from vertex 1:
+                b[1], n+1, m12,
+                b[1], m01, n+1,
+                // two faces straddling edge from vertex 2:
+                b[2], n+2, m23,
+                b[2], m12, n+2,
+                // two faces straddling edge from vertex 3:
+                b[3], n+3, m30,
+                b[3], m23, n+3,
+                // four faces from edge (0,1), (1,2), (2,3), (3,0):
+                b[0], m01, b[1],
+                b[1], m12, b[2],
+                b[2], m23, b[3],
+                b[3], m30, b[0],
+            ]);
+
+            self.child(xform * self.splits[0], self.depth,[c, m12, n+2, m23]);
+            self.child(xform * self.splits[1], self.depth,[c, m01, n+1, m12]);
+            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]);
         }
     }
 }

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());