Beginnings of a mesh parser. Also cleaned up some unused imports.

src/assembly.rs

@@ -3,8 +3,7 @@ use std::collections::HashMap;
 use math::Matrix4x4;
 use bvh::BVH;
 use boundable::Boundable;
-use surface::{Surface, SurfaceIntersection};
+use surface::Surface;
-use ray::Ray;
 use bbox::{BBox, transform_bbox_slice_from};
 
 

src/main.rs

@@ -29,13 +29,7 @@ use std::fs::File;
 
 use docopt::Docopt;
 
-use math::{Point, Matrix4x4};
 use ray::Ray;
-use camera::Camera;
-use scene::Scene;
-use assembly::{AssemblyBuilder, Object};
-use renderer::Renderer;
-use surface::triangle_mesh::TriangleMesh;
 use parse::{parse_scene, DataTree};
 
 // ----------------------------------------------------------------

src/parse/basics.rs

@@ -10,8 +10,10 @@ use nom::IResult::*;
 // Parsers for numbers surrounded by whitespace
 named!(pub ws_u32<u32>, delimited!(opt!(multispace), u32_utf8, opt!(multispace)));
 named!(pub ws_u64<u64>, delimited!(opt!(multispace), u64_utf8, opt!(multispace)));
+named!(pub ws_usize<usize>, delimited!(opt!(multispace), usize_utf8, opt!(multispace)));
 named!(pub ws_i32<i32>, delimited!(opt!(multispace), i32_utf8, opt!(multispace)));
 named!(pub ws_i64<i64>, delimited!(opt!(multispace), i64_utf8, opt!(multispace)));
+named!(pub ws_isize<isize>, delimited!(opt!(multispace), isize_utf8, opt!(multispace)));
 named!(pub ws_f32<f32>, delimited!(opt!(multispace), f32_utf8, opt!(multispace)));
 named!(pub ws_f64<f64>, delimited!(opt!(multispace), f64_utf8, opt!(multispace)));
 
@@ -52,6 +54,22 @@ named!(pub i64_utf8<i64>, chain!(
         }
 ));
 
+named!(pub usize_utf8<usize>, chain!(
+        bytes: digit,
+        || { str::from_utf8(bytes).unwrap().parse::<usize>().unwrap() }
+));
+
+named!(pub isize_utf8<isize>, chain!(
+        sign: one_of!("-+")? ~
+        bytes: digit,
+        || {
+            match sign {
+                Some(s) if s == '-' => -str::from_utf8(bytes).unwrap().parse::<isize>().unwrap(),
+                _ => str::from_utf8(bytes).unwrap().parse::<isize>().unwrap(),
+            }
+        }
+));
+
 named!(pub f32_utf8<f32>, chain!(
         bytes: take_decimal_real,
         || {

src/parse/data_tree.rs

@@ -2,7 +2,7 @@
 
 use std::result::Result;
 use std::cmp::Eq;
-use std::iter::{Iterator, Filter};
+use std::iter::Iterator;
 use std::slice;
 
 #[derive(Debug, Eq, PartialEq)]
@@ -184,7 +184,7 @@ impl<'a> Iterator for DataTreeFilterInternalIter<'a> {
     fn next(&mut self) -> Option<(&'a str, Option<&'a str>, &'a Vec<DataTree<'a>>)> {
         loop {
             match self.iter.next() {            
-                Some(&DataTree::Internal{type_name: type_name, ident: ident, children: ref children}) => {
+                Some(&DataTree::Internal{type_name, ident, ref children}) => {
                     if type_name == self.type_name {
                         return Some((type_name, ident, children));
                     } else {
@@ -223,7 +223,7 @@ impl<'a> Iterator for DataTreeFilterLeafIter<'a> {
                     continue;
                 }
 
-                Some(&DataTree::Leaf{type_name: type_name, contents: contents}) => {
+                Some(&DataTree::Leaf{type_name, contents}) => {
                     if type_name == self.type_name {
                         return Some((type_name, contents));
                     } else {

src/parse/mod.rs

@@ -1,6 +1,7 @@
 mod data_tree;
 mod psy;
 mod psy_assembly;
+mod psy_mesh_surface;
 pub mod basics;
 
 pub use self::data_tree::DataTree;

src/parse/psy_assembly.rs

@@ -2,16 +2,9 @@
 
 use std::result::Result;
 
-use nom;
-use nom::IResult;
-
 use super::DataTree;
-use super::basics::{ws_u32, ws_f32};
 use super::psy::{parse_matrix, PsyParseError};
 
-use math::Matrix4x4;
-use camera::Camera;
-use renderer::Renderer;
 use assembly::{Assembly, AssemblyBuilder};
 
 pub fn parse_assembly(tree: &DataTree) -> Result<Assembly, PsyParseError> {

src/parse/psy_mesh_surface.rs

@@ -0,0 +1,69 @@
+#![allow(dead_code)]
+
+use std::result::Result;
+
+use nom;
+use nom::IResult;
+
+use super::DataTree;
+use super::basics::{ws_usize, ws_f32};
+use super::psy::PsyParseError;
+
+use surface::triangle_mesh::TriangleMesh;
+use math::Point;
+
+// pub struct TriangleMesh {
+//    time_samples: usize,
+//    geo: Vec<(Point, Point, Point)>,
+//    indices: Vec<usize>,
+//    accel: BVH,
+// }
+
+pub fn parse_mesh_surface(tree: &DataTree) -> Result<TriangleMesh, PsyParseError> {
+    let mut verts = Vec::new();
+    let mut face_vert_counts = Vec::new();
+    let mut face_vert_indices = Vec::new();
+
+    // TODO: make sure there are the right number of various children,
+    // and other validation.
+
+    // Get verts
+    // TODO: store vert count for a single round and make sure all rounds
+    // have the same count.
+    for (_, text) in tree.iter_leaf_children_with_type("Vertices") {
+        let mut raw_text = text.trim().as_bytes();
+
+        while let IResult::Done(remaining, vert) = closure!(tuple!(ws_f32,
+                                                                   ws_f32,
+                                                                   ws_f32))(raw_text) {
+            raw_text = remaining;
+
+            verts.push(Point::new(vert.0, vert.1, vert.2));
+        }
+    }
+
+    // Get face vert counts
+    if let Some((_, text)) = tree.iter_leaf_children_with_type("FaceVertCounts").nth(0) {
+        let mut raw_text = text.trim().as_bytes();
+
+        while let IResult::Done(remaining, count) = ws_usize(raw_text) {
+            raw_text = remaining;
+
+            face_vert_counts.push(count);
+        }
+    }
+
+    // Get face vert indices
+    if let Some((_, text)) = tree.iter_leaf_children_with_type("FaceVertIndices").nth(0) {
+        let mut raw_text = text.trim().as_bytes();
+
+        while let IResult::Done(remaining, index) = ws_usize(raw_text) {
+            raw_text = remaining;
+
+            face_vert_indices.push(index);
+        }
+    }
+
+    // TODO: build triangle mesh
+    unimplemented!();
+}

src/renderer.rs

@@ -3,12 +3,10 @@
 use std::path::Path;
 
 use tracer::Tracer;
-use camera::Camera;
 use halton;
 use math::fast_logit;
 use image::Image;
 use surface;
-use surface::Surface;
 use scene::Scene;
 
 #[derive(Debug)]