extern crate gltf;

use glium::{ VertexBuffer, IndexBuffer };

#[derive(Copy, Clone)]
struct Vertex {
    position: [f32; 3],
    normal: [f32; 3],
}

implement_vertex!(Vertex, position, normal);

pub struct Model {
    vb: VertexBuffer<Vertex>,
    ib: IndexBuffer<u32>,
}

impl Model {
    pub fn new(display: &glium::Display, file: &str) -> Self {
	let (document, buffers, _images) = gltf::import(file).expect("Could not load gltf file");
	let mesh = document.meshes().next().unwrap();
	let primitive = mesh.primitives().next().unwrap();
	let reader = primitive.reader(|buffer| Some(&buffers[buffer.index()]));

	let mut vertices: Vec<Vertex> = Vec::new();
	let positions = reader.read_positions().unwrap();
	let normals = reader.read_normals().unwrap();
	for (position, normal) in positions.zip(normals) {
	    vertices.push(Vertex { position, normal });
	}   
	let vb = VertexBuffer::new(display, &vertices).unwrap();
	
	let indices: Vec<u32> = reader.read_indices().unwrap().into_u32().collect();
	let ib = IndexBuffer::new(display, glium::index::PrimitiveType::TrianglesList, &indices).unwrap();

	Model { vb, ib }
    }

    pub fn draw(&self,
		target: &mut impl glium::Surface,
		program: &glium::Program,
		uniforms: &impl glium::uniforms::Uniforms,
		params: &glium::DrawParameters
    ) {
	target.draw(&self.vb, &self.ib, program, uniforms, params).unwrap()
    }
}
