Add scratch work before refactor. Examples in this rev are likely broken.
This commit is contained in:
Chris Hodapp
parent
10d5314157
commit
0ad03ac77d
@ -15,3 +15,4 @@ debug = true
|
||||
euclid = "0.20.7"
|
||||
nalgebra = "0.19.0"
|
||||
stl_io = "0.4.2"
|
||||
rand = "0.7.3"
|
||||
|
||||
467
src/examples.rs
467
src/examples.rs
@ -1,9 +1,10 @@
|
||||
use std::rc::Rc;
|
||||
use nalgebra::*;
|
||||
use rand::Rng;
|
||||
//pub mod examples;
|
||||
|
||||
use crate::openmesh::{OpenMesh, Tag};
|
||||
use crate::xform::{Transform, vertex};
|
||||
use crate::xform::{Transform, vertex, Mat4};
|
||||
use crate::rule::{Rule, RuleFn, RuleEval, Child};
|
||||
use crate::prim;
|
||||
use crate::util;
|
||||
@ -15,7 +16,7 @@ pub fn cube_thing() -> Rule<()> {
|
||||
//let x = &Vector3::x_axis();
|
||||
let y = &Vector3::y_axis();
|
||||
let z = &Vector3::z_axis();
|
||||
|
||||
|
||||
// Each element of this turns to a branch for the recursion:
|
||||
let id = Transform::new();
|
||||
let turns: Vec<Transform> = vec![
|
||||
@ -40,10 +41,98 @@ pub fn cube_thing() -> Rule<()> {
|
||||
}).collect(),
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
Rule { eval: Rc::new(rec), ctxt: () }
|
||||
}
|
||||
|
||||
pub fn barbs() -> Rule<()> {
|
||||
|
||||
let base_verts = vec![
|
||||
vertex(-0.5, -0.5, 0.0),
|
||||
vertex(-0.5, 0.5, 0.0),
|
||||
vertex( 0.5, 0.5, 0.0),
|
||||
vertex( 0.5, -0.5, 0.0),
|
||||
];
|
||||
let n = base_verts.len();
|
||||
|
||||
let incr: Transform = Transform::new().
|
||||
translate(0.0, 0.0, 1.0).
|
||||
rotate(&Vector3::z_axis(), 0.1).
|
||||
scale(0.95);
|
||||
|
||||
let b = base_verts.clone();
|
||||
let barb = move |self_: Rc<Rule<()>>| -> RuleEval<()> {
|
||||
let next_verts = incr.transform(&b);
|
||||
|
||||
let geom = Rc::new(util::zigzag_to_parent(next_verts.clone(), n));
|
||||
let (vc, faces) = util::connect_convex(&next_verts, true);
|
||||
let final_geom = Rc::new(OpenMesh {
|
||||
verts: vec![vc],
|
||||
faces: faces,
|
||||
});
|
||||
|
||||
RuleEval {
|
||||
geom: geom,
|
||||
final_geom: final_geom,
|
||||
children: vec![
|
||||
Child {
|
||||
rule: self_.clone(),
|
||||
xf: incr,
|
||||
vmap: (0..n).collect(),
|
||||
}
|
||||
]
|
||||
}
|
||||
};
|
||||
|
||||
let b = base_verts.clone();
|
||||
let main = move |self_: Rc<Rule<()>>| -> RuleEval<()> {
|
||||
let next_verts = incr.transform(&b);
|
||||
|
||||
// TODO: Once I start doing the barbs this will go away
|
||||
let geom = Rc::new(util::zigzag_to_parent(next_verts.clone(), n));
|
||||
let (vc, faces) = util::connect_convex(&next_verts, true);
|
||||
let final_geom = Rc::new(OpenMesh {
|
||||
verts: vec![vc],
|
||||
faces: faces,
|
||||
});
|
||||
|
||||
RuleEval {
|
||||
geom: geom,
|
||||
final_geom: final_geom,
|
||||
children: vec![
|
||||
Child {
|
||||
rule: self_.clone(),
|
||||
xf: incr,
|
||||
vmap: (0..n).collect(),
|
||||
}
|
||||
]
|
||||
}
|
||||
};
|
||||
|
||||
let main_ = Rc::new(main);
|
||||
let base = move |self_: Rc<Rule<()>>| -> RuleEval<()> {
|
||||
RuleEval {
|
||||
geom: Rc::new(OpenMesh {
|
||||
verts: base_verts.clone(),
|
||||
faces: vec![
|
||||
Tag::Body(0), Tag::Body(1), Tag::Body(2),
|
||||
Tag::Body(0), Tag::Body(2), Tag::Body(3),
|
||||
],
|
||||
}),
|
||||
final_geom: Rc::new(prim::empty_mesh()),
|
||||
children: vec![
|
||||
Child {
|
||||
rule: Rc::new(Rule { eval: main_.clone(), ctxt: () }),
|
||||
xf: Transform::new(),
|
||||
vmap: (0..n).collect(),
|
||||
},
|
||||
],
|
||||
}
|
||||
};
|
||||
|
||||
Rule { eval: Rc::new(base), ctxt: () }
|
||||
}
|
||||
|
||||
// Meant to be a copy of twist_from_gen from Python &
|
||||
// automata_scratch, but has since acquired a sort of life of its own
|
||||
pub fn twist(f: f32, subdiv: usize) -> Rule<()> {
|
||||
@ -137,6 +226,126 @@ pub fn twist(f: f32, subdiv: usize) -> Rule<()> {
|
||||
Rule { eval: Rc::new(start), ctxt: () }
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct NestSpiral2Ctxt {
|
||||
init: bool,
|
||||
stack: [Transform; 2],
|
||||
}
|
||||
|
||||
pub fn nest_spiral_2() -> Rule<NestSpiral2Ctxt> {
|
||||
let subdiv = 8;
|
||||
let seed = vec![
|
||||
vertex(-0.5, -0.5, 0.0),
|
||||
vertex(-0.5, 0.5, 0.0),
|
||||
vertex( 0.5, 0.5, 0.0),
|
||||
vertex( 0.5, -0.5, 0.0),
|
||||
];
|
||||
let seed = util::subdivide_cycle(&seed, subdiv);
|
||||
|
||||
let n = seed.len();
|
||||
let geom = Rc::new(util::zigzag_to_parent(seed.clone(), n));
|
||||
let (vc, faces) = util::connect_convex(&seed, true);
|
||||
let final_geom = Rc::new(OpenMesh {
|
||||
verts: vec![vc],
|
||||
faces: faces,
|
||||
});
|
||||
|
||||
let rad = 1.0;
|
||||
let dz = 0.1;
|
||||
let rz = 0.1;
|
||||
let rad2 = 4.0;
|
||||
let rz2 = 0.1;
|
||||
|
||||
let recur = move |self_: Rc<Rule<NestSpiral2Ctxt>>| -> RuleEval<NestSpiral2Ctxt> {
|
||||
//let x = &Vector3::x_axis();
|
||||
let z = &Vector3::z_axis();
|
||||
let stack = self_.ctxt.stack;
|
||||
let next_rule = Rule {
|
||||
eval: self_.eval.clone(),
|
||||
ctxt: NestSpiral2Ctxt {
|
||||
init: false,
|
||||
stack: [
|
||||
Transform::new().rotate(z, rz2) * stack[0],
|
||||
Transform::new().translate(0.0, 0.0, dz).rotate(z, rz) * stack[1],
|
||||
],
|
||||
},
|
||||
};
|
||||
let xf = stack.iter().fold(Transform::new(), |acc,m| acc * (*m));
|
||||
if self_.ctxt.init {
|
||||
let mut s2 = seed.clone();
|
||||
let (centroid, f) = util::connect_convex(&s2, false);
|
||||
s2.push(centroid);
|
||||
let n2 = s2.len();
|
||||
let g = OpenMesh { verts: s2, faces: f };
|
||||
RuleEval {
|
||||
geom: Rc::new(g.transform(&xf)),
|
||||
final_geom: Rc::new(prim::empty_mesh()),
|
||||
children: vec![
|
||||
Child {
|
||||
rule: Rc::new(next_rule),
|
||||
xf: Transform::new(),
|
||||
vmap: (0..n2).collect(),
|
||||
},
|
||||
],
|
||||
}
|
||||
} else {
|
||||
RuleEval {
|
||||
geom: Rc::new(geom.transform(&xf)),
|
||||
final_geom: Rc::new(final_geom.transform(&xf)),
|
||||
children: vec![
|
||||
Child {
|
||||
rule: Rc::new(next_rule),
|
||||
xf: Transform::new(),
|
||||
vmap: (0..n).collect(),
|
||||
},
|
||||
],
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
let count = 3;
|
||||
|
||||
let r = Rc::new(recur);
|
||||
let start = move |self_: Rc<Rule<NestSpiral2Ctxt>>| -> RuleEval<NestSpiral2Ctxt> {
|
||||
let z = &Vector3::z_axis();
|
||||
let child = |i: usize| -> Child<NestSpiral2Ctxt> {
|
||||
let ang = std::f32::consts::PI * 2.0 * (i as f32) / (count as f32);
|
||||
Child {
|
||||
rule: Rc::new(Rule {
|
||||
eval: r.clone(),
|
||||
ctxt: NestSpiral2Ctxt {
|
||||
init: true,
|
||||
stack: [
|
||||
Transform::new().translate(rad2, 0.0, 0.0),
|
||||
Transform::new().rotate(z, ang).translate(rad, 0.0, 0.0),
|
||||
],
|
||||
},
|
||||
}),
|
||||
xf: Transform::new(),
|
||||
vmap: vec![], // no parent vertices
|
||||
}
|
||||
};
|
||||
|
||||
RuleEval {
|
||||
geom: Rc::new(prim::empty_mesh()),
|
||||
final_geom: Rc::new(prim::empty_mesh()),
|
||||
children: (0..count).map(child).collect(),
|
||||
}
|
||||
};
|
||||
|
||||
Rule {
|
||||
eval: Rc::new(start),
|
||||
ctxt: NestSpiral2Ctxt {
|
||||
init: true,
|
||||
stack: [ // doesn't matter
|
||||
Transform::new(),
|
||||
Transform::new(),
|
||||
],
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct TorusCtxt {
|
||||
init: bool,
|
||||
@ -236,6 +445,78 @@ pub fn twisty_torus() -> Rule<TorusCtxt> {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn twisty_torus_hardcode() -> Rule<()> {
|
||||
let subdiv = 8;
|
||||
let seed = vec![
|
||||
vertex(-0.5, -0.5, 0.0),
|
||||
vertex(-0.5, 0.5, 0.0),
|
||||
vertex( 0.5, 0.5, 0.0),
|
||||
vertex( 0.5, -0.5, 0.0),
|
||||
];
|
||||
let xf = Transform::new().rotate(&Vector3::x_axis(), -0.9);
|
||||
let seed = util::subdivide_cycle(&xf.transform(&seed), subdiv);
|
||||
let incr = Transform { mtx: Mat4::from_vec(vec![
|
||||
0.955234, 0.29576725, -0.0070466697, 0.0,
|
||||
-0.29581502, 0.9552189, -0.007100463, 0.0,
|
||||
0.004630968, 0.008867174, 0.99994993, 0.0,
|
||||
-0.034161568, 0.290308, 0.07295418, 0.9999999,
|
||||
])};
|
||||
|
||||
let n = seed.len();
|
||||
|
||||
let next = incr.transform(&seed);
|
||||
let geom = Rc::new(util::zigzag_to_parent(next.clone(), n));
|
||||
let (vc, faces) = util::connect_convex(&next, true);
|
||||
let final_geom = Rc::new(OpenMesh {
|
||||
verts: vec![vc],
|
||||
faces: faces,
|
||||
});
|
||||
|
||||
let rad = 1.0;
|
||||
let rad2 = 8.0;
|
||||
let rad3 = 24.0;
|
||||
|
||||
let start = Transform::new().translate(0.0, rad3, 0.0) * Transform::new().translate(0.0, rad2, 0.0) * Transform::new().translate(rad, 0.0, 0.0);
|
||||
|
||||
let recur = move |self_: Rc<Rule<()>>| -> RuleEval<()> {
|
||||
RuleEval {
|
||||
geom: geom.clone(),
|
||||
final_geom: final_geom.clone(),
|
||||
children: vec![
|
||||
Child {
|
||||
rule: self_.clone(),
|
||||
xf: incr,
|
||||
vmap: (0..n).collect(),
|
||||
},
|
||||
],
|
||||
}
|
||||
};
|
||||
|
||||
let start = move |self_: Rc<Rule<()>>| -> RuleEval<()> {
|
||||
let mut s2 = seed.clone();
|
||||
let (centroid, f) = util::connect_convex(&s2, false);
|
||||
s2.push(centroid);
|
||||
let n2 = s2.len();
|
||||
let g = OpenMesh { verts: s2, faces: f };
|
||||
RuleEval {
|
||||
geom: Rc::new(g.transform(&xf)),
|
||||
final_geom: Rc::new(prim::empty_mesh()),
|
||||
children: vec![
|
||||
Child {
|
||||
rule: Rc::new(Rule { eval: Rc::new(recur.clone()), ctxt: () }),
|
||||
xf: incr,
|
||||
vmap: (0..n2).collect(),
|
||||
},
|
||||
],
|
||||
}
|
||||
};
|
||||
|
||||
Rule {
|
||||
eval: Rc::new(start),
|
||||
ctxt: (),
|
||||
}
|
||||
}
|
||||
|
||||
// This was a mistake that I'd like to understand later:
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct WindChimeCtxt {
|
||||
@ -491,16 +772,7 @@ pub fn ramhorn_branch(depth: usize, f: f32) -> Rule<RamHornCtxt> {
|
||||
let next = incr.transform(&seed);
|
||||
let geom = Rc::new(OpenMesh {
|
||||
verts: next,
|
||||
faces: vec![
|
||||
Tag::Body(1), Tag::Parent(0), Tag::Body(0),
|
||||
Tag::Parent(1), Tag::Parent(0), Tag::Body(1),
|
||||
Tag::Body(2), Tag::Parent(1), Tag::Body(1),
|
||||
Tag::Parent(2), Tag::Parent(1), Tag::Body(2),
|
||||
Tag::Body(3), Tag::Parent(2), Tag::Body(2),
|
||||
Tag::Parent(3), Tag::Parent(2), Tag::Body(3),
|
||||
Tag::Body(0), Tag::Parent(3), Tag::Body(3),
|
||||
Tag::Parent(0), Tag::Parent(3), Tag::Body(0),
|
||||
],
|
||||
faces: util::parallel_zigzag_faces(4),
|
||||
});
|
||||
let final_geom = Rc::new(OpenMesh {
|
||||
verts: vec![],
|
||||
@ -646,6 +918,175 @@ pub fn ramhorn_branch(depth: usize, f: f32) -> Rule<RamHornCtxt> {
|
||||
Rule { eval: Rc::new(start), ctxt: RamHornCtxt { depth } }
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct RamHornCtxt2 {
|
||||
depth: usize,
|
||||
}
|
||||
|
||||
pub fn ramhorn_branch_random(depth: usize, f: f32) -> Rule<RamHornCtxt2> {
|
||||
|
||||
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).
|
||||
rotate(&v, 0.4 * f).
|
||||
scale(1.0 - (1.0 - 0.95)*f);
|
||||
|
||||
let seed = vec![
|
||||
vertex(-0.5, -0.5, 0.0),
|
||||
vertex(-0.5, 0.5, 0.0),
|
||||
vertex( 0.5, 0.5, 0.0),
|
||||
vertex( 0.5, -0.5, 0.0),
|
||||
];
|
||||
let next = incr.transform(&seed);
|
||||
let geom = Rc::new(OpenMesh {
|
||||
verts: next,
|
||||
faces: util::parallel_zigzag_faces(4),
|
||||
});
|
||||
let final_geom = Rc::new(OpenMesh {
|
||||
verts: vec![],
|
||||
faces: vec![
|
||||
Tag::Parent(0), Tag::Parent(2), Tag::Parent(1),
|
||||
Tag::Parent(0), Tag::Parent(3), Tag::Parent(2),
|
||||
],
|
||||
});
|
||||
|
||||
let opening_xform = |i| {
|
||||
let r = std::f32::consts::FRAC_PI_2 * i;
|
||||
Transform::new().
|
||||
rotate(&nalgebra::Vector3::z_axis(), r).
|
||||
translate(0.25, 0.25, 0.0).
|
||||
scale(0.5)
|
||||
};
|
||||
|
||||
// 'transition' geometry (when something splits):
|
||||
let trans_verts = vec![
|
||||
// 'Top' vertices:
|
||||
vertex(-0.5, -0.5, 0.0), // 0 (above 9)
|
||||
vertex(-0.5, 0.5, 0.0), // 1 (above 10)
|
||||
vertex( 0.5, 0.5, 0.0), // 2 (above 11)
|
||||
vertex( 0.5, -0.5, 0.0), // 3 (above 12)
|
||||
// Top edge midpoints:
|
||||
vertex(-0.5, 0.0, 0.0), // 4 (connects 0-1)
|
||||
vertex( 0.0, 0.5, 0.0), // 5 (connects 1-2)
|
||||
vertex( 0.5, 0.0, 0.0), // 6 (connects 2-3)
|
||||
vertex( 0.0, -0.5, 0.0), // 7 (connects 3-0)
|
||||
// Top middle:
|
||||
vertex( 0.0, 0.0, 0.0), // 8
|
||||
];
|
||||
let trans_faces = vec![
|
||||
// two faces straddling edge from vertex 0:
|
||||
Tag::Parent(0), Tag::Body(0), Tag::Body(4),
|
||||
Tag::Parent(0), Tag::Body(7), Tag::Body(0),
|
||||
// two faces straddling edge from vertex 1:
|
||||
Tag::Parent(1), Tag::Body(1), Tag::Body(5),
|
||||
Tag::Parent(1), Tag::Body(4), Tag::Body(1),
|
||||
// two faces straddling edge from vertex 2:
|
||||
Tag::Parent(2), Tag::Body(2), Tag::Body(6),
|
||||
Tag::Parent(2), Tag::Body(5), Tag::Body(2),
|
||||
// two faces straddling edge from vertex 3:
|
||||
Tag::Parent(3), Tag::Body(3), Tag::Body(7),
|
||||
Tag::Parent(3), Tag::Body(6), Tag::Body(3),
|
||||
// four faces from edge (0,1), (1,2), (2,3), (3,0):
|
||||
Tag::Parent(0), Tag::Body(4), Tag::Parent(1),
|
||||
Tag::Parent(1), Tag::Body(5), Tag::Parent(2),
|
||||
Tag::Parent(2), Tag::Body(6), Tag::Parent(3),
|
||||
Tag::Parent(3), Tag::Body(7), Tag::Parent(0),
|
||||
];
|
||||
let trans_geom = Rc::new(OpenMesh {
|
||||
verts: trans_verts.clone(),
|
||||
faces: trans_faces.clone(),
|
||||
});
|
||||
let trans_children = move |recur: RuleFn<RamHornCtxt2>, ctxt: RamHornCtxt2| {
|
||||
vec![
|
||||
Child {
|
||||
rule: Rc::new(Rule { eval: recur.clone(), ctxt }),
|
||||
xf: opening_xform(0.0),
|
||||
vmap: vec![5,2,6,8],
|
||||
},
|
||||
Child {
|
||||
rule: Rc::new(Rule { eval: recur.clone(), ctxt }),
|
||||
xf: opening_xform(1.0),
|
||||
vmap: vec![4,1,5,8],
|
||||
},
|
||||
Child {
|
||||
rule: Rc::new(Rule { eval: recur.clone(), ctxt }),
|
||||
xf: opening_xform(2.0),
|
||||
vmap: vec![7,0,4,8],
|
||||
},
|
||||
Child {
|
||||
rule: Rc::new(Rule { eval: recur.clone(), ctxt }),
|
||||
xf: opening_xform(3.0),
|
||||
vmap: vec![6,3,7,8],
|
||||
},
|
||||
// TODO: These vertex mappings appear to be right.
|
||||
// Explain *why* they are right.
|
||||
// TODO: Factor out the repetition here.
|
||||
]
|
||||
};
|
||||
|
||||
let tg = trans_geom.clone();
|
||||
// TODO: Why is that necessary?
|
||||
let recur = move |self_: Rc<Rule<RamHornCtxt2>>| -> RuleEval<RamHornCtxt2> {
|
||||
if self_.ctxt.depth <= 0 {
|
||||
let d2 = rand::thread_rng().gen_range(2, 60);
|
||||
RuleEval {
|
||||
geom: tg.clone(),
|
||||
final_geom: final_geom.clone(),
|
||||
// This final_geom will leave midpoint/centroid
|
||||
// vertices, but stopping here means none are
|
||||
// connected anyway - so they can just be ignored.
|
||||
children: trans_children(self_.eval.clone(), RamHornCtxt2 { depth: d2 }),
|
||||
}
|
||||
} else {
|
||||
let next_rule = Rule {
|
||||
eval: self_.eval.clone(),
|
||||
ctxt: RamHornCtxt2 { depth: self_.ctxt.depth - 1 },
|
||||
};
|
||||
RuleEval {
|
||||
geom: geom.clone(),
|
||||
final_geom: final_geom.clone(),
|
||||
children: vec![
|
||||
Child {
|
||||
rule: Rc::new(next_rule),
|
||||
xf: incr,
|
||||
vmap: vec![0,1,2,3],
|
||||
},
|
||||
],
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
let trans = move |self_: Rc<Rule<RamHornCtxt2>>| -> RuleEval<RamHornCtxt2> {
|
||||
RuleEval {
|
||||
geom: trans_geom.clone(),
|
||||
final_geom: Rc::new(prim::empty_mesh()),
|
||||
children: trans_children(Rc::new(recur.clone()), self_.ctxt),
|
||||
}
|
||||
};
|
||||
|
||||
let start = move |self_: Rc<Rule<RamHornCtxt2>>| -> RuleEval<RamHornCtxt2> {
|
||||
RuleEval {
|
||||
geom: Rc::new(OpenMesh {
|
||||
verts: Transform::new().translate(0.0, 0.0, -0.5).transform(&seed),
|
||||
faces: vec![
|
||||
Tag::Body(0), Tag::Body(1), Tag::Body(2),
|
||||
Tag::Body(0), Tag::Body(2), Tag::Body(3),
|
||||
],
|
||||
}),
|
||||
final_geom: Rc::new(prim::empty_mesh()),
|
||||
children: vec![
|
||||
Child {
|
||||
rule: Rc::new(Rule { eval: Rc::new(trans.clone()), ctxt: self_.ctxt }),
|
||||
xf: Transform::new(),
|
||||
vmap: vec![0,1,2,3],
|
||||
},
|
||||
],
|
||||
}
|
||||
};
|
||||
|
||||
Rule { eval: Rc::new(start), ctxt: RamHornCtxt2 { depth } }
|
||||
}
|
||||
|
||||
/*
|
||||
#[derive(Copy, Clone)]
|
||||
struct CurveHorn {
|
||||
|
||||
21
src/lib.rs
21
src/lib.rs
@ -70,6 +70,9 @@ mod tests {
|
||||
run_test(examples::cube_thing(), 3, "cube_thing3", false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn barbs() { run_test(examples::barbs(), 20, "barbs", false); }
|
||||
|
||||
#[test]
|
||||
fn twist() {
|
||||
run_test(examples::twist(1.0, 2), 200, "screw", false);
|
||||
@ -81,14 +84,27 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn twisty_torus_hardcode() {
|
||||
run_test(examples::twisty_torus_hardcode(), 1000, "twisty_torus_hardcode", false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn twisty_torus_full() {
|
||||
run_test(examples::twisty_torus(), 40000, "twisty_torus_full", false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn wind_chime_mistake_thing() {
|
||||
run_test(examples::wind_chime_mistake_thing(), 400, "wind_chime_mistake_thing", false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nest_spiral_2() {
|
||||
run_test(examples::nest_spiral_2(), 200, "nest_spiral_2", false);
|
||||
}
|
||||
|
||||
// This one is very time-consuming to run:
|
||||
#[test]
|
||||
#[ignore]
|
||||
@ -106,6 +122,11 @@ mod tests {
|
||||
fn ramhorn_branch() {
|
||||
run_test(examples::ramhorn_branch(24, 0.25), 32, "ram_horn_branch", false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ramhorn_branch_random() {
|
||||
run_test(examples::ramhorn_branch_random(24, 0.25), 32, "ram_horn_branch_random", false);
|
||||
}
|
||||
}
|
||||
// need this for now:
|
||||
// cargo test -- --nocapture
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user