Moved file loading out of main

Author: ecumene

src/inputs.rs

@@ -1,6 +1,8 @@
 use clap::{App, Arg, ArgMatches, SubCommand};
-use crate::geometry::{SimpleMesh, ToSimpleMeshWithMaterial};
+use crate::geometry::{SimpleMesh, ToSimpleMeshWithMaterial, ToSimpleMesh};
 use crate::context::{Context};
+use std::fs::OpenOptions;
+use std::path::Path;
 use std::error::Error;
 
 pub fn cli_matches<'a>() -> ArgMatches<'a> {
@@ -84,6 +86,39 @@ pub fn to_meshes(models: Vec<tobj::Model>, materials: Vec<tobj::Material>) -> Ve
     meshes
 }
 
+pub fn match_meshes(matches: &ArgMatches) -> Result<Vec<SimpleMesh>, Box<Error>> {
+    let mut mesh_queue: Vec<SimpleMesh> = vec![];
+    for slice in matches.value_of("INPUT FILENAME").unwrap().split(' ') {
+        let error = |s: &str, e: &str| -> Result<Vec<SimpleMesh>, Box<Error>> {
+            Err(format!("filename: [{}] couldn't load, {}. {}", slice, s, e).into())
+        };
+        // Fill list with file inputs (Splits for spaces -> multiple files)
+        let path = Path::new(slice);
+        let mut meshes = match path.extension() {
+            None => error("couldn't determine filename extension", ""),
+            Some(ext) => match ext.to_str() {
+                None => error("couldn't parse filename extension", ""),
+                Some(extstr) => match &*extstr.to_lowercase() {
+                    "obj" => match tobj::load_obj(&path) {
+                        Err(e) => error("tobj couldnt load/parse OBJ", &e.to_string()),
+                        Ok(present) => Ok(to_meshes(present.0, present.1)),
+                    },
+                    "stl" => match OpenOptions::new().read(true).open(&path) {
+                        Err(e) => error("STL load failed", &e.to_string()),
+                        Ok(mut file) => match stl_io::read_stl(&mut file) {
+                            Err(e) => error("stl_io couldnt parse STL", &e.to_string()),
+                            Ok(stlio_mesh) => Ok(vec![stlio_mesh.to_simple_mesh()]),
+                        },
+                    },
+                    _ => error("unknown filename extension", ""),
+                },
+            },
+        };
+        mesh_queue.append(&mut meshes.unwrap());
+    }
+    Ok(mesh_queue)
+}
+
 pub fn match_turntable(matches: &ArgMatches) -> Result<(f32, f32, f32, f32), Box<Error>> {
     let mut turntable = (0.0, 0.0, 0.0, 0.0);
     if let Some(x) = matches.value_of("x")  {

src/main.rs

@@ -1,9 +1,7 @@
 use crossterm::{cursor, Crossterm, InputEvent, KeyEvent, RawScreen};
 use std::error::Error;
 use std::f32;
-use std::fs::OpenOptions;
 use std::io::{stdout, Write};
-use std::path::Path;
 use std::time::Instant;
 
 use nalgebra::Rotation3;
@@ -22,37 +20,8 @@ pub use inputs::*;
 
 fn main() -> Result<(), Box<Error>> {
     let matches = cli_matches(); // Read command line arguments
-    let mut mesh_queue: Vec<SimpleMesh> = vec![]; // A list of meshes to render
-    for slice in matches.value_of("INPUT FILENAME").unwrap().split(' ') {
-        let error = |s: &str, e: &str| -> Vec<SimpleMesh> {
-            println!("filename: [{}] couldn't load, {}. {}", slice, s, e);
-            vec![]
-        };
-        // Fill list with file inputs (Splits for spaces -> multiple files)
-        let path = Path::new(slice);
-        let mut meshes = match path.extension() {
-            None => error("couldn't determine filename extension", ""),
-            Some(ext) => match ext.to_str() {
-                None => error("couldn't parse filename extension", ""),
-                Some(extstr) => match &*extstr.to_lowercase() {
-                    "obj" => match tobj::load_obj(&path) {
-                        Err(e) => error("tobj couldnt load/parse OBJ", &e.to_string()),
-                        Ok(present) => to_meshes(present.0, present.1),
-                    },
-                    "stl" => match OpenOptions::new().read(true).open(&path) {
-                        Err(e) => error("STL load failed", &e.to_string()),
-                        Ok(mut file) => match stl_io::read_stl(&mut file) {
-                            Err(e) => error("stl_io couldnt parse STL", &e.to_string()),
-                            Ok(stlio_mesh) => vec![stlio_mesh.to_simple_mesh()],
-                        },
-                    },
-                    _ => error("unknown filename extension", ""),
-                },
-            },
-        };
-        mesh_queue.append(&mut meshes);
-    }
 
+    let mesh_queue: Vec<SimpleMesh> = match_meshes(&matches)?; // A list of meshes to render
     let mut turntable = match_turntable(&matches)?;
     let crossterm = Crossterm::new();
     let input = crossterm.input();
@@ -88,17 +57,21 @@ fn main() -> Result<(), Box<Error>> {
     let mut last_time; // Used in the variable time step
     loop {
         last_time = Instant::now();
-        if let Some(b) = stdin.next() {
-            match b {
-                InputEvent::Keyboard(event) => match event {
-                    KeyEvent::Char('q') => break,
+        if !context.image {
+            if let Some(b) = stdin.next() {
+                match b {
+                    InputEvent::Keyboard(event) => match event {
+                        KeyEvent::Char('q') => {
+                            cursor.show()?;
+                            break;
+                        },
+                        _ => {}
+                    },
                     _ => {}
-                },
-                _ => {}
+                }
             }
         }
-        let rot =
-            Rotation3::from_euler_angles(turntable.0, turntable.1, turntable.2).to_homogeneous();
+        let rot = Rotation3::from_euler_angles(turntable.0, turntable.1, turntable.2).to_homogeneous();
         context.update(size, &mesh_queue)?; // This checks for if there needs to be a context update
         context.clear(); // This clears the z and frame buffer
         for mesh in &mesh_queue {
@@ -134,6 +107,5 @@ fn main() -> Result<(), Box<Error>> {
         }
     }
 
-    cursor.show()?;
     Ok(())
 }