Starting to work on rendering

src/math/vector.rs

@@ -31,6 +31,12 @@ macro_rules! make_vector {
             }
         }
 
+        impl<T> Into<[T; $number]> for $name<T> {
+            fn into(self) -> [T; $number] {
+                self.data
+            }
+        }
+
         impl<T: Copy + Clone> Into<($( $t ) ,* )> for $name<T> {
             fn into(self) -> ($( $t ) ,* ) {
                 ( $( self.data[$y] ), *)

src/model.rs

@@ -8,6 +8,15 @@ use parser::{parse, ParserError};
 use math::vector::{Vector2, Vector3};
 use math::bounding_box::BoundingBox3;
 
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct Vertex {
+    vertex:    [f64; 3],
+    tex_coord: [f64; 2],
+    normal:    [f64; 3],
+}
+
+implement_vertex!(Vertex, vertex, tex_coord, normal);
+
 #[derive(Copy, Clone, PartialEq)]
 /// The indices needed for each vertex of a face.
 pub struct FaceVertex {
@@ -154,6 +163,23 @@ impl Part {
         f.material_name = self.material_name.clone();
         self.faces.push(f);
     }
+
+    pub fn build_shape(&self, vertices: &Vec<Vector3<f64>>, tex_coords: &Vec<Vector2<f64>>, normals: &Vec<Vector3<f64>>) -> Vec<Vertex> {
+
+        let mut shape = vec![];
+        for face in &self.faces {
+            for &&v in &[&face.a, &face.b, &face.c] {
+                shape.push(Vertex {
+                    vertex:    vertices[v.vertex].into(),
+                    tex_coord: tex_coords[v.texture_coordinate.unwrap()].into(),
+                    normal: normals[v.normal.unwrap()].into(),
+                });
+            }
+        }
+
+        shape
+    }
+
 }
 
 /// A 3D model.

src/programs/viewer.rs

@@ -1,4 +1,5 @@
 extern crate glium;
+extern crate model_converter;
 
 use glium::Display;
 use glium::glutin;
@@ -12,6 +13,9 @@ use glium::glutin::Event;
 use glium::glutin::WindowEvent;
 use glium::glutin::VirtualKeyCode;
 
+use model_converter::parser::parse;
+use model_converter::renderer::Renderer;
+
 fn main() {
 
     let mut events_loop = EventsLoop::new();
@@ -19,20 +23,16 @@ fn main() {
     let context = ContextBuilder::new();
     let display = Display::new(window, context, &events_loop).unwrap();
 
-    let program = glium::Program::from_source(
-        &display,
-        include_str!("../../assets/shaders/shader.vert"),
-        include_str!("../../assets/shaders/shader.frag"),
-        None
-    ).unwrap();
-
     let mut closed = false;
 
-    while !closed {
-        let mut target = display.draw();
+    let model = parse("./assets/models/toonlink/link.obj").unwrap();
+    let mut renderer = Renderer::new(display);
+    renderer.add_model(&model);
 
-        use glium::Surface;
-        target.clear_color(0.0, 0.0, 1.0, 1.0);
+    while !closed {
+
+        let mut target = renderer.draw();
+        renderer.render(&mut target);
 
         target.finish().unwrap();
 

src/renderer.rs

@@ -1 +1,68 @@
-pub struct Renderer;
+use glium::index::{
+    NoIndices,
+    PrimitiveType
+};
+use glium::{
+    Program,
+    Display,
+    VertexBuffer,
+    Frame,
+};
+
+use model::{Model, Vertex};
+
+pub struct Renderer<'a> {
+    display: Display,
+    program: Program,
+    models: Vec<(&'a Model, Vec<VertexBuffer<Vertex>>)>,
+}
+
+impl<'a> Renderer<'a> {
+    pub fn new(display: Display) -> Renderer<'a> {
+
+        let program = Program::from_source(
+            &display,
+            include_str!("../assets/shaders/shader.vert"),
+            include_str!("../assets/shaders/shader.frag"),
+            None
+        ).unwrap();
+
+        Renderer {
+            display: display,
+            program: program,
+            models: vec![],
+        }
+    }
+
+    pub fn add_model(&mut self, model: &'a Model) {
+        let mut buffers = vec![];
+
+        for part in &model.parts {
+            let shape = part.build_shape(&model.vertices, &model.texture_coordinates, &model.normals);
+            buffers.push(VertexBuffer::new(&self.display, &shape).unwrap());
+        }
+
+        self.models.push((model, buffers));
+    }
+
+    pub fn draw(&self) -> Frame {
+        self.display.draw()
+    }
+
+    pub fn render(&self, target: &mut Frame) {
+        use glium::Surface;
+        target.clear_color(0.0, 0.0, 0.0, 1.0);
+
+        for &(_, ref buffers) in &self.models {
+            for buffer in buffers {
+                target.draw(
+                    buffer,
+                    NoIndices(PrimitiveType::TrianglesList),
+                    &self.program,
+                    &uniform!(),
+                    &Default::default(),
+                ).unwrap();
+            }
+        }
+    }
+}