Some quite aggressive commit... 😢

src/programs/viewer.rs

@@ -1,8 +1,15 @@
+extern crate clap;
 extern crate glium;
+#[macro_use]
+extern crate verbose_log;
 extern crate model_converter;
 
-use std::env;
+use std::rc::Rc;
+use std::cell::RefCell;
 use std::process::exit;
+use std::time::{Instant, Duration};
+
+use clap::{App, Arg};
 
 use glium::Display;
 use glium::glutin;
@@ -16,59 +23,99 @@ use glium::glutin::WindowEvent;
 use glium::glutin::VirtualKeyCode;
 
 
+use model_converter::math::bounding_box::BoundingBox3;
 use model_converter::math::vector::Vector3;
-use model_converter::parser::parse_into_model;
+use model_converter::parser::parse;
 use model_converter::renderer::Renderer;
-use model_converter::renderer::controls::OrbitControls;
-use model_converter::renderer::controls::FirstPersonControls;
-use model_converter::renderer::camera::Camera;
-use model_converter::model::Model;
+use model_converter::controls::OrbitControls;
+use model_converter::controls::FirstPersonControls;
+use model_converter::camera::Camera;
+
+fn as_millis(duration: Duration) -> u64 {
+    duration.as_secs() * 1_000 + (duration.subsec_nanos() as u64) / 1_000_000
+}
 
 fn main() {
 
-    let mut model = Model::new();
-    let mut inputs = vec![];
-    let mut iterator = env::args();
+    let matches = App::new("3D Viewer")
+        .version("1.0")
+        .arg(Arg::with_name("input")
+             .short("i")
+             .long("input")
+             .value_name("FILES")
+             .takes_value(true)
+             .multiple(true)
+             .help("Input model files")
+             .required(true))
+        .arg(Arg::with_name("first person")
+             .short("f")
+             .long("first-person")
+             .takes_value(false)
+             .help("Uses first person controls instead of orbit controls"))
+        .arg(Arg::with_name("verbose")
+             .short("v")
+             .long("verbose")
+             .help("Shows logs during the parsing of the model"))
+        .get_matches();
 
-    // Skip the name of the program
-    iterator.next();
+    // Set verbose flag
+    verbose_log::log::VERBOSE.with(|verbose| {
+        *verbose.borrow_mut() = matches.occurrences_of("verbose") > 0;
+    });
 
-    while let Some(argument) = iterator.next() {
-        match argument.as_ref() {
-            "-i" | "--input" => {
-                if let Some(path) = iterator.next() {
-                    inputs.push(path);
-                } else {
-                    eprintln!("Expecting path after {}", argument);
-                    exit(-1);
-                }
+    use std::f64::{MIN, MAX};
+    let mut bbox = BoundingBox3::new(
+        Vector3::new(MAX, MAX, MAX),
+        Vector3::new(MIN, MIN, MIN),
+    );
+
+    let mut models = vec![];
+
+    for input in matches.values_of("input").unwrap() {
+        match parse(&input) {
+            Ok(model) => {
+                bbox = bbox.union(&model.bounding_box());
+                models.push((input.to_owned(), model))
             },
-
-            arg => {
-                eprintln!("Argument unkown: {}", arg);
-                exit(-1);
+            Err(e) => {
+                eprintln!("Error while parsing file: {}", e);
+                exit(1);
             },
         }
     }
 
-    for input in inputs {
-        if let Err(e) = parse_into_model(&input, &mut model) {
-            eprintln!("Error while parsing file: {}", e);
-            exit(1);
-        }
-    }
-
-    model.center_and_scale();
-
     let mut events_loop = EventsLoop::new();
     let window = WindowBuilder::new().with_visibility(false);
     let context = glutin::ContextBuilder::new().with_depth_buffer(24);
     let display = Display::new(window, context, &events_loop).unwrap();
     let mut renderer = Renderer::new(display);
 
-    let mut closed = false;
+    let mut scene = vec![];
+    let mut before;
+    let mut duration;
 
-    renderer.add_model(&model);
+    for (name, mut model) in models {
+        log!("Scaling model {}...", name);
+        model.center_and_scale_from_box(&bbox);
+
+        log!("\nBuilding textures for model {}...", name);
+
+        before = Instant::now();
+        model.build_textures(&renderer);
+        duration = Instant::now().duration_since(before);
+
+        log!(" done in {}ms.\nBuilding vertex buffers for model {}...",
+             as_millis(duration) ,name);
+
+        before = Instant::now();
+        model.build_vertex_buffers(&renderer);
+        duration = Instant::now().duration_since(before);
+
+        scene.push(Rc::new(RefCell::new(model)));
+        logln!(" done in {}ms.\nFinished", as_millis(duration));
+    }
+
+    let mut closed = false;
 
     let mut camera = Camera::new(
         Vector3::new( 0.0, 0.0, 0.0),
@@ -76,13 +123,21 @@ fn main() {
         Vector3::new( 0.0, 1.0, 0.0),
     );
 
-    camera.z_near = 0.00001;
+    camera.z_near = 0.0001;
 
-    let mut controls = FirstPersonControls::new();
+    let mut controls: Box<Controls> = if matches.value_of("first person").is_some() {
+        Box::new(FirstPersonControls::new())
+    } else {
+        Box::new(OrbitControls::new(
+            Vector3::new(0.0, 0.0, 0.0),
+            1.0,
+            &mut camera
+        ))
+    };
 
     renderer.show();
 
-    use model_converter::renderer::controls::Controls;
+    use model_converter::controls::Controls;
     while !closed {
 
         events_loop.poll_events(|ev| {
@@ -109,10 +164,7 @@ fn main() {
         });
 
         controls.update(&mut camera, &renderer);
-
-        let mut target = renderer.draw();
-        renderer.render(&camera, &mut target);
-        target.finish().unwrap();
+        renderer.render(&scene, &camera);
 
     }
 }