hodapp/prosha
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Revert some of 120ede4b

Browse Source
This commit is contained in:
hodapp 2020-03-04 20:47:13 -05:00
parent 13279f61ed
commit 313aa6203f
1 changed files with 18 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
src/rule.rs
View File

@ -102,7 +102,7 @@ impl<A> Rule<A> {
// TODO: This logic is more or less right, but it // TODO: This logic is more or less right, but it
// could perhaps use some un-tupling or something. // could perhaps use some un-tupling or something.
let subgeom: Vec<(OpenMesh, Vec<usize>)> = rs.children.iter().map(|sub| { let subgeom: Vec<(OpenMesh, &Vec<usize>)> = rs.children.iter().map(|sub| {
// Get sub-geometry (still un-transformed): // Get sub-geometry (still un-transformed):
let (submesh, eval) = sub.rule.to_mesh(arg, iters_left - 1); let (submesh, eval) = sub.rule.to_mesh(arg, iters_left - 1);
// Tally up eval count: // Tally up eval count:
@ -110,8 +110,7 @@ impl<A> Rule<A> {
let m2 = submesh.transform(&sub.xf); let m2 = submesh.transform(&sub.xf);
// TODO: Can I avoid the .clone() here? (m2, &sub.vmap)
(m2, sub.vmap.clone())
}).collect(); }).collect();
// Connect geometry from this rule (not child rules): // Connect geometry from this rule (not child rules):
@ -134,8 +133,6 @@ impl<A> Rule<A> {
// is, not including any transform of any element of // is, not including any transform of any element of
// 'rules'. // 'rules'.
xf: Mat4, xf: Mat4,
// Child geometry for 'rules', waiting to be connected:
geom: Vec<(OpenMesh, Vec<usize>)>,
} }
let mut geom = prim::empty_mesh(); let mut geom = prim::empty_mesh();
@ -149,7 +146,6 @@ impl<A> Rule<A> {
rules: eval.children, rules: eval.children,
next: 0, next: 0,
xf: nalgebra::geometry::Transform3::identity().to_homogeneous(), xf: nalgebra::geometry::Transform3::identity().to_homogeneous(),
geom: vec![],
}; };
stack.push(s); stack.push(s);
geom = eval.geom; geom = eval.geom;
@ -172,18 +168,24 @@ impl<A> Rule<A> {
// TODO: This, more elegantly? // TODO: This, more elegantly?
count += 1; count += 1;
if count > max_depth {
break;
}
let n = stack.len(); // TODO: Just keep a running total. let n = stack.len(); // TODO: Just keep a running total.
println!("DEBUG: stack has len {}", n); println!("DEBUG: stack has len {}", n);
// We can increment/decrement as we push/pop. // We can increment/decrement as we push/pop.
let s = &mut stack[n-1]; let s = &mut stack[n-1];
if s.next >= s.rules.len() || count > max_depth { if s.next >= s.rules.len() {
// Connect the geometry we accumulated:
println!("DEBUG: Connecting {} parts", s.geom.len());
geom = geom.connect(&s.geom);
// If we've run out of child rules, backtrack: // If we've run out of child rules, backtrack:
stack.pop(); stack.pop();
// 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; continue;
} }
@ -194,22 +196,21 @@ impl<A> Rule<A> {
let eval = f(arg); let eval = f(arg);
// Compose child transform to new world transform: // Compose child transform to new world transform:
let xf = child.xf * s.xf; // TODO: Check order on this let xf = s.xf * child.xf; // TODO: Check order on this
let new_geom = eval.geom.transform(&xf); let new_geom = eval.geom.transform(&xf);
println!("DEBUG: Connecting {} faces, faces={:?}",
s.next += 1; new_geom.verts.len(), new_geom.faces);
s.geom.push((new_geom, child.vmap.clone())); geom = geom.connect(&vec![(new_geom, &child.vmap)]);
// TODO: this clone() shouldn't be necessary
// Recurse further (i.e. put more onto stack): // Recurse further (i.e. put more onto stack):
let s2 = State { let s2 = State {
rules: eval.children, rules: eval.children,
next: 0, next: 0,
xf: xf, xf: xf,
geom: vec![],
}; };
stack.push(s2); stack.push(s2);
}, },
Rule::EmptyRule => { Rule::EmptyRule => {
s.next += 1; s.next += 1;