From 6a8f0e14c8f42cd1a101efe6fc70a5dad215fba9 Mon Sep 17 00:00:00 2001
From: Chris Hodapp <hodapp87@gmail.com>
Date: Sun, 1 Mar 2020 19:32:45 -0500
Subject: [PATCH] Progressed with to_mesh_iter (still not quite working)

---
 src/examples.rs | 11 +++++++++++
 src/rule.rs     | 22 ++++++++++++++++++----
 2 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/src/examples.rs b/src/examples.rs
index 68db177..f481376 100644
--- a/src/examples.rs
+++ b/src/examples.rs
@@ -412,6 +412,15 @@ pub fn main() {
         mesh.write_stl_file(&fname).unwrap();
     }
 
+    fn run_test_iter<A>(a: A, r: Rule<A>, iters: usize, name: &str) {
+        println!("Running {}...", name);
+        let (mesh, nodes) = r.to_mesh_iter(&a, iters);
+        println!("Merged {} nodes", nodes);
+        let fname = format!("{}.stl", name);
+        println!("Writing {}...", fname);
+        mesh.write_stl_file(&fname).unwrap();
+    }
+    
     run_test(CubeThing::init(), Rule::Recurse(CubeThing::rec), 3, "cube_thing");
     // this can't work on its own because the resultant OpenMesh still
     // has parent references:
@@ -419,4 +428,6 @@ pub fn main() {
     run_test(CurveHorn::init(), Rule::Recurse(CurveHorn::start), 100, "curve_horn2");
     run_test(RamHorn::init(), Rule::Recurse(RamHorn::start), 200, "ram_horn");
     run_test(Twist::init(), Rule::Recurse(Twist::start), 200, "twist");
+
+    run_test_iter(CurveHorn::init(), Rule::Recurse(CurveHorn::start), 100, "curve_horn2_iter");
 }
diff --git a/src/rule.rs b/src/rule.rs
index 9274e72..d3fc82f 100644
--- a/src/rule.rs
+++ b/src/rule.rs
@@ -156,17 +156,30 @@ impl<A> Rule<A> {
             },
         }
 
+        let mut count = 0;
+        
         while !stack.is_empty() {
+
+            // TODO: This, more elegantly?
+            count += 1;
+            if count > max_depth {
+                break;
+            }
             
             let n = stack.len(); // TODO: Just keep a running total.
+            println!("DEBUG: stack has len {}", n);
             // We can increment/decrement as we push/pop.
             let s = &mut stack[n-1];
 
             if s.next >= s.rules.len() {
                 // If we've run out of child rules, backtrack:
                 stack.pop();
-                // TODO: If we're backtracking, then the *parent* node
-                // needs to have 'next' incremented.
+                // and have the *parent* node (if one) move on:
+                if n >= 2 {
+                    stack[n-2].next += 1;
+                }
+                // (if there isn't one, it makes no difference,
+                // because the loop will end)
                 continue;
             }
 
@@ -178,8 +191,9 @@ impl<A> Rule<A> {
 
                     // Compose child transform to new world transform:
                     let xf = s.xf * child.xf; // TODO: Check order on this
-                    
-                    // TODO: Add in new geometry, transformed with 'xf'
+
+                    let new_geom = eval.geom.transform(&xf);
+                    geom = geom.connect(&vec![(new_geom, &child.vmap)]);
                     
                     // Recurse further (i.e. put more onto stack):                    
                     let s2 = State {