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

Clean up some cruft

Browse Source
This commit is contained in:
Chris Hodapp 2020-01-01 15:48:54 -05:00
parent 33702834b0
commit 55ccfc682f
1 changed files with 11 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
src/main.rs
View File

@ -12,14 +12,15 @@ enum Rule {
struct RuleStep {
// The geometry generated at this step
geom: Mesh,
// The next rule to run on this geometry
// The next rule to run on this geometry. If EmptyRule, then stop
// here (and 'xform' is irrelevant).
rule: Box<Rule>,
// The transformation to apply to any results of 'rule' (if
// applicable)
xform: Mat4,
}
fn test_rule(_v: Vec<Mesh>) -> Vec<RuleStep> {
fn cube_thing_rule(_v: Vec<Mesh>) -> Vec<RuleStep> {
let mesh = MeshBuilder::new().cube().build().unwrap();
@ -40,7 +41,7 @@ fn test_rule(_v: Vec<Mesh>) -> Vec<RuleStep> {
let m: Mat4 = rot *
Matrix4::from_scale(0.5) *
Matrix4::from_translation(vec3(6.0, 0.0, 0.0));
let r = Rule::Recurse(test_rule);
let r = Rule::Recurse(cube_thing_rule);
let mut m2 = mesh.clone();
m2.apply_transformation(m);
RuleStep { geom: m2, rule: Box::new(r), xform: m }
@ -55,7 +56,11 @@ fn test_rule(_v: Vec<Mesh>) -> Vec<RuleStep> {
// TODO: Do I want to make 'geom' shared somehow, maybe with Rc? I
// could end up having a lot of identical geometry that need not be
// duplicated until it is transformed into the global space
// duplicated until it is transformed into the global space.
//
// This might produce bigger gains if I rewrite rule_to_mesh so that
// rather than repeatedly transforming meshes, it stacks
// transformations and then applies them all at once.
fn rule_to_mesh(rule: &Rule, iters_left: u32) -> (Mesh, u32) {
@ -90,28 +95,6 @@ fn rule_to_mesh(rule: &Rule, iters_left: u32) -> (Mesh, u32) {
(mesh, nodes)
}
// This isn't kosher:
//type Rule = fn (Vec<Mesh>) -> (Mesh, Vec<(Mesh, Box<Rule>)>);
fn mesh_builder_example() -> Result<Mesh, tri_mesh::mesh_builder::Error> {
let indices: Vec<u32> = vec![0, 1, 2,
0, 2, 3,
0, 3, 1];
let positions: Vec<f64> = vec![0.0, 0.0, 0.0,
1.0, 0.0, -0.5,
-1.0, 0.0, -0.5,
0.0, 0.0, 1.0];
let mesh = MeshBuilder::new().
with_indices(indices).
with_positions(positions).
build()?;
assert_eq!(mesh.no_faces(), 3);
assert_eq!(mesh.no_vertices(), 4);
Ok(mesh)
}
fn print_vector(v: &Vec4) -> String {
return format!("{},{},{},{}", v.x, v.y, v.z, v.w);
}
@ -139,38 +122,9 @@ fn main() {
// Export the bounding box to an obj file
std::fs::write("foo.obj", mesh.parse_as_obj()).unwrap();
// Try some vector stuff:
let r = Rule::Recurse(cube_thing_rule);
let m: Mat4 = Matrix4::from_translation(vec3(5.0, 0.0, 0.0));
println!("translation: ");
print_matrix(&m);
/*print_vector(&m.x);
print_vector(&m.y);
print_vector(&m.z);
print_vector(&m.w);*/
let m2: Mat4 = Matrix4::from_scale(2.0);
println!("scale: ");
print_matrix(&m2);
let m3 = m * m2;
println!("translation * scale: ");
print_matrix(&m3);
let m4 = m2 * m;
println!("scale * translation: ");
print_matrix(&m4);
let mut mesh2 = mesh_builder_example().unwrap();
std::fs::write("foo2.obj", mesh2.parse_as_obj()).unwrap();
mesh2.apply_transformation(m);
mesh2.append(&mesh);
std::fs::write("foo3.obj", mesh2.parse_as_obj()).unwrap();
let r = Rule::Recurse(test_rule);
let max_iters = 4;
let max_iters = 2;
println!("Running rules...");
let (cubemesh, nodes) = rule_to_mesh(&r, max_iters);
println!("Collected {} nodes, produced {} faces, {} vertices",