use glam::{Mat4, Vec3, Vec4, Quat};
use nom::{
	IResult,
	bytes::complete::{tag},
	number::complete::{le_u32},
};

use sdl2::event::Event;
use sdl2::keyboard::{Keycode, Scancode};
use std::collections::HashMap;
use std::convert::TryInto;
use std::ffi::{c_void, CStr, CString};
use std::fs::File;
use std::io::Read;
use std::path::Path;
use std::time::{Duration, Instant};

mod iqm_consts {
	pub const VERSION: usize           =  0;
	pub const FILESIZE: usize          =  1;
	pub const FLAGS: usize             =  2;
	pub const NUM_TEXT: usize          =  3;
	pub const OFS_TEXT: usize          =  4;
	pub const NUM_MESHES: usize        =  5;
	pub const OFS_MESHES: usize        =  6;
	pub const NUM_VERTEXARRAYS: usize  =  7;
	pub const NUM_VERTEXES: usize      =  8;
	pub const OFS_VERTEXARRAYS: usize  =  9;
	pub const NUM_TRIANGLES: usize     = 10;
	pub const OFS_TRIANGLES: usize     = 11;
	pub const OFS_ADJACENCY: usize     = 12;
	pub const NUM_JOINTS: usize        = 13;
	pub const OFS_JOINTS: usize        = 14;
	pub const NUM_POSES: usize         = 15;
	pub const OFS_POSES: usize         = 16;
	pub const NUM_ANIMS: usize         = 17;
	pub const OFS_ANIMS: usize         = 18;
	pub const NUM_FRAMES: usize        = 19;
	pub const NUM_FRAMECHANNELS: usize = 20;
	pub const OFS_FRAMES: usize        = 21;
	pub const OFS_BOUNDS: usize        = 22;
	pub const NUM_COMMENT: usize       = 23;
	pub const OFS_COMMENT: usize       = 24;
	pub const NUM_EXTENSIONS: usize    = 25;
	pub const OFS_EXTENSIONS: usize    = 26;
}

mod iqm_types {
	pub const POSITION: u32     = 0;
	pub const TEXCOORD: u32     = 1;
	pub const NORMAL: u32       = 2;
	pub const TANGENT: u32      = 3;
	pub const BLENDINDEXES: u32 = 4;
	pub const BLENDWEIGHTS: u32 = 5;
	pub const COLOR: u32        = 6;
	pub const CUSTOM: u32       = 0x10;
}

mod iqm_formats {
	pub const BYTE: u32   = 0;
	pub const UBYTE: u32  = 1;
	pub const SHORT: u32  = 2;
	pub const USHORT: u32 = 3;
	pub const INT: u32    = 4;
	pub const UINT: u32   = 5;
	pub const HALF: u32   = 6;
	pub const FLOAT: u32  = 7;
	pub const DOUBLE: u32 = 8;
}

#[derive (Debug)]
pub struct IqmMesh {
	name: u32,
	material: u32,
	first_vertex: u32,
	num_vertexes: u32,
	first_triangle: u32,
	num_triangles: u32,
}

#[derive (Debug)]
pub struct IqmHeader {
	fields: [u32; 27],
}

#[derive (Debug)]
pub struct IqmVertexArray {
	va_type: u32,
	va_flags: u32,
	va_format: u32,
	va_size: u32,
	va_offset: u32,
}

#[derive (Debug)]
pub struct IqmModel <'a> {
	data: &'a [u8],
	
	header: IqmHeader,
	text: Vec <u8>,
	meshes: Vec <IqmMesh>,
	vertexarrays: Vec <IqmVertexArray>,
}

impl IqmHeader {
	pub fn from_slice (input: &[u8]) -> IResult <&[u8], IqmHeader> {
		let (input, _) = tag (b"INTERQUAKEMODEL\0")(input)?;
		let (input, version) = le_u32 (input)?;
		
		// I only know how to parse version 2
		assert_eq! (version, 2);
		
		let mut input = input;
		let mut fields = [0; 27];
		fields [0] = version;
		
		for index in 1..fields.len () {
			let (i, h) = le_u32 (input)?;
			input = i;
			fields [usize::from (index)] = h;
		}
		
		Ok ((input, IqmHeader {
			fields,
		}))
	}
}

impl IqmMesh {
	pub fn from_slice (input: &[u8]) -> IResult <&[u8], IqmMesh> {
		let mut result = IqmMesh {
			name: 0,
			material: 0,
			first_vertex: 0,
			num_vertexes: 0,
			first_triangle: 0,
			num_triangles: 0,
		};
		
		let mut input = input;
		for field in [
			&mut result.name,
			&mut result.material,
			&mut result.first_vertex,
			&mut result.num_vertexes,
			&mut result.first_triangle,
			&mut result.num_triangles,
		].iter_mut () {
			let (i, f) = le_u32 (input)?;
			input = i;
			**field = f;
		}
		
		Ok ((input, result))
	}
}

impl IqmVertexArray {
	pub fn from_slice (input: &[u8]) -> IResult <&[u8], IqmVertexArray> {
		let mut result = IqmVertexArray {
			va_type: 0,
			va_flags: 0,
			va_format: 0,
			va_size: 0,
			va_offset: 0,
		};
		
		let mut input = input;
		for field in [
			&mut result.va_type,
			&mut result.va_flags,
			&mut result.va_format,
			&mut result.va_size,
			&mut result.va_offset,
		].iter_mut () {
			let (i, f) = le_u32 (input)?;
			input = i;
			**field = f;
		}
		
		Ok ((input, result))
	}
}

impl <'a> IqmModel <'a> {
	pub fn from_slice (data: &'a [u8]) -> IqmModel <'a> {
		let header = IqmHeader::from_slice (data).unwrap ().1;
		
		let text = {
			let offset: usize = header.fields [iqm_consts::OFS_TEXT].try_into ().unwrap ();
			let num: usize = header.fields [iqm_consts::NUM_TEXT].try_into ().unwrap ();
			Vec::from (&data [offset..offset + num])
		};
		
		let meshes = {
			let num: usize = header.fields [iqm_consts::NUM_MESHES].try_into ().unwrap ();
			let mut meshes = Vec::with_capacity (num);
			let mesh_size = 6 * 4;
			let meshes_offset: usize = header.fields [iqm_consts::OFS_MESHES].try_into ().unwrap ();
			
			for i in 0..num {
				let offset = meshes_offset + i * mesh_size;
				let mesh_slice = &data [offset..offset + mesh_size];
				
				meshes.push (IqmMesh::from_slice (mesh_slice).unwrap ().1);
			}
			meshes
		};
		
		//println! ("{:?}", meshes);
		
		let vertexarrays = {
			let num: usize = header.fields [iqm_consts::NUM_VERTEXARRAYS].try_into ().unwrap ();
			let mut vertexarrays = Vec::with_capacity (num);
			let vertexarray_size = 5 * 4;
			let vertexarrays_offset: usize = header.fields [iqm_consts::OFS_VERTEXARRAYS].try_into ().unwrap ();
			
			for i in 0..num {
				let offset = vertexarrays_offset + i * vertexarray_size;
				let vertexarray_slice = &data [offset..offset + vertexarray_size];
				
				let vertexarray = IqmVertexArray::from_slice (vertexarray_slice).unwrap ().1;
				
				//println! ("{:?}", vertexarray);
				
				vertexarrays.push (vertexarray);
			}
			
			vertexarrays
		};
		
		IqmModel {
			data,
			
			header,
			text,
			meshes,
			vertexarrays,
		}
	}
	
	pub fn get_vertex_slice (&self, 
		vertexarray_index: usize
	) -> &[u8]
	{
		let vertexarray = &self.vertexarrays [vertexarray_index];
		let bytes_per_float = 4;
		let stride = bytes_per_float * vertexarray.va_size;
		//assert_eq! (stride, 12);
		
		let offset: usize = (vertexarray.va_offset).try_into ().unwrap ();
		let num_bytes: usize = (stride * self.header.fields [iqm_consts::NUM_VERTEXES]).try_into ().unwrap ();
		
		&self.data [offset..offset + num_bytes]
	}
	
	pub fn get_index_slice (&self, mesh_index: usize) -> &[u8] {
		let mesh = &self.meshes [mesh_index];
		let bytes_per_u32 = 4;
		let indexes_per_tri = 3;
		let stride = bytes_per_u32 * indexes_per_tri;
		
		let offset: usize = (self.header.fields [iqm_consts::OFS_TRIANGLES] + stride * mesh.first_triangle).try_into ().unwrap ();
		
		let num_bytes: usize = (stride * mesh.num_triangles).try_into ().unwrap ();
		
		&self.data [offset..offset + num_bytes]
	}
}

pub fn load_small_file <P> (name: P) -> Vec <u8>
where P: AsRef <Path> 
{
	let mut f = File::open (name).unwrap ();
	let len = f.metadata ().unwrap ().len ();
	
	if len > 1024 * 1024 {
		panic! ("File is too big");
	}
	
	let mut data = vec! [0u8; len.try_into ().unwrap ()];
	
	f.read (&mut data [..]).unwrap ();
	
	data
}

pub fn ugly_load_texture <P> (name: P) -> u32
where P: AsRef <Path>
{
	let decoder = png::Decoder::new (File::open (name).unwrap ());
	let (info, mut reader) = decoder.read_info ().unwrap ();
	// Allocate the output buffer.
	let mut buf = vec! [0; info.buffer_size ()];
	// Read the next frame. Currently this function should only called once.
	// The default options
	reader.next_frame (&mut buf).unwrap ();
	
	unsafe {
		gl::BindTexture (gl::TEXTURE_2D, 1);
		gl::TexImage2D (gl::TEXTURE_2D, 0, gl::RGBA.try_into ().unwrap (), 1024, 1024, 0, gl::RGBA, gl::UNSIGNED_BYTE, &buf [0] as *const u8 as *const c_void);
		
		gl::TexParameteri (gl::TEXTURE_2D, gl::TEXTURE_WRAP_S, gl::CLAMP_TO_EDGE as i32);
		gl::TexParameteri (gl::TEXTURE_2D, gl::TEXTURE_WRAP_T, gl::CLAMP_TO_EDGE as i32);
		gl::TexParameteri (gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::NEAREST as i32);
		gl::TexParameteri (gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::NEAREST as i32);
	}
	
	1
}

const VERT_SHADER_SRC: &str = 
"
#define lowp
#define mediump
#define highp
#line 0
uniform highp mat4 uni_mvp;

attribute highp vec4 attr_pos;
attribute mediump vec2 attr_uv;
attribute lowp vec3 attr_normal;

varying mediump vec2 vary_uv;
varying lowp vec3 vary_normal;

void main (void) {
	vary_uv = attr_uv;
	
	lowp vec4 light_color = vec4 (1.0);
	
	vary_normal = attr_normal;
	
	gl_Position = uni_mvp * attr_pos;
}";

const FRAG_SHADER_SRC: &str = 
"
#define lowp
#define mediump
#define highp
#line 0
uniform lowp sampler2D uni_texture;
uniform lowp vec3 uni_albedo;
uniform lowp vec3 uni_object_space_light;
uniform lowp vec3 uni_min_bright;
uniform lowp vec3 uni_min_albedo;

//varying lowp vec4 vary_color;
varying lowp vec3 vary_normal;
varying mediump vec2 vary_uv;

void main (void) {
	lowp vec3 normal = normalize (vary_normal);
	
	lowp vec3 albedo = uni_albedo * max (uni_min_albedo, texture2D (uni_texture, vary_uv).rgb);
	//lowp vec3 albedo = vec3 (vary_uv, 0.0);
	
	lowp float diffuse_factor = dot (normal, uni_object_space_light);
	lowp vec3 sun = max (diffuse_factor, 0.0) * vec3 (0.95, 0.9, 0.85);
	lowp vec3 sky = (diffuse_factor * 0.45 + 0.55) * vec3 (0.05, 0.1, 0.15);
	lowp vec3 diffuse_color = albedo * max (uni_min_bright, (sun + sky));
	
	gl_FragColor = vec4 (sqrt (diffuse_color), 1.0);
}
";

pub struct ShaderObject {
	id: u32,
}

impl ShaderObject {
	pub fn id (&self) -> u32 {
		self.id
	}
	
	pub fn new (shader_type: u32, source: &str) -> Result <ShaderObject, String>
	{
		let id = unsafe {
			gl::CreateShader (shader_type)
		};
		
		let sources = [
			source.as_ptr () as *const i8,
		];
		
		let lengths = [
			source.len ().try_into ().unwrap (),
		];
		
		let success = unsafe {
			gl::ShaderSource (id, sources.len ().try_into ().unwrap (), sources.as_ptr (), lengths.as_ptr ());
			gl::CompileShader (id);
			
			let mut success = 0;
			gl::GetShaderiv (id, gl::COMPILE_STATUS, &mut success);
			success == 1
		};
		
		if success {
			Ok (ShaderObject {
				id,
			})
		}
		else {
			let mut info_log = vec! [0u8; 4096];
			let mut log_length = 0;
			
			unsafe {
				gl::GetShaderInfoLog (id, (info_log.len () - 1).try_into ().unwrap (), &mut log_length, info_log.as_mut_ptr () as *mut i8);
			}
			
			info_log.truncate (log_length.try_into ().unwrap ());
			
			let info = String::from_utf8 (info_log).unwrap ();
			
			Err (info)
		}
	}
}

impl Drop for ShaderObject {
	fn drop (&mut self) {
		unsafe {
			gl::DeleteShader (self.id);
		}
	}
}

pub struct ShaderProgram {
	id: u32,
}

impl ShaderProgram {
	pub fn new (vert: &ShaderObject, frag: &ShaderObject) 
	-> Result <ShaderProgram, String> 
	{
		let id = unsafe {
			gl::CreateProgram ()
		};
		
		unsafe {
			gl::AttachShader (id, vert.id ());
			gl::AttachShader (id, frag.id ());
			
			gl::LinkProgram (id);
		}
		
		let success = unsafe {
			let mut success = 0;
			gl::GetProgramiv (id, gl::LINK_STATUS, &mut success);
			success == 1
		};
		
		if success {
			Ok (ShaderProgram {
				id,
			})
		}
		else {
			let mut info_log = vec! [0u8; 4096];
			let mut log_length = 0;
			
			unsafe {
				gl::GetProgramInfoLog (id, (info_log.len () - 1).try_into ().unwrap (), &mut log_length, info_log.as_mut_ptr () as *mut i8);
			}
			
			info_log.truncate (log_length.try_into ().unwrap ());
			
			let info = String::from_utf8 (info_log).unwrap ();
			
			Err (info)
		}
	}
	
	pub fn get_uniform_location (&self, name: &CStr) -> i32 {
		unsafe {
			gl::UseProgram (self.id);
			gl::GetUniformLocation (self.id, name.as_ptr ())
		}
	}
	
	pub fn get_attribute_location (&self, name: &CStr) -> i32 {
		unsafe {
			gl::UseProgram (self.id);
			gl::GetAttribLocation (self.id, name.as_ptr ())
		}
	}
}

impl Drop for ShaderProgram {
	fn drop (&mut self) {
		unsafe {
			gl::DeleteProgram (self.id);
		}
	}
}

fn enable_vertex_attrib_array (id: Option <u32>) {
	match id {
		Some (id) => unsafe {
			gl::EnableVertexAttribArray (id);
		},
		_ => (),
	}
}

unsafe fn vertex_attrib_pointer (id: Option <u32>, num_coords: i32, slice: &[u8]) {
	const FALSE_U8: u8 = 0;
	const FLOAT_SIZE: i32 = 4;
	match id {
		Some (id) => {
			gl::VertexAttribPointer (id, num_coords, gl::FLOAT, FALSE_U8, FLOAT_SIZE * num_coords, &slice [0] as *const u8 as *const c_void);
		},
		_ => (),
	}
}

unsafe fn point_to_model (
	attrs: &HashMap <String, Option <u32>>, 
	model: &IqmModel
) {
	vertex_attrib_pointer (attrs ["pos"], 3, model.get_vertex_slice (0));
	vertex_attrib_pointer (attrs ["uv"], 2, model.get_vertex_slice (1));
	vertex_attrib_pointer (attrs ["normal"], 3, model.get_vertex_slice (2));
}

const KEY_LEFT: usize = 0;
const KEY_RIGHT: usize = KEY_LEFT + 1;
const KEY_UP: usize = KEY_RIGHT + 1;
const KEY_DOWN: usize = KEY_UP + 1;
const KEY_COUNT: usize = KEY_DOWN + 1;

struct ControllerState {
	keys: Vec <bool>,
}

impl ControllerState {
	pub fn from_sdl_keyboard (k: &sdl2::keyboard::KeyboardState) -> Self {
		let f = |c| k.is_scancode_pressed (c);
		
		Self {
			keys: vec! [
				f (Scancode::Left),
				f (Scancode::Right),
				f (Scancode::Up),
				f (Scancode::Down),
			],
		}
	}
	
	pub fn is_pressed (&self, code: usize) -> bool {
		self.keys [code]
	}
}

struct WorldState {
	azimuth: f32,
	altitude: f32,
	spin_speed: i32,
}

impl WorldState {
	pub fn new () -> Self {
		Self {
			azimuth: 0.0,
			altitude: 0.0,
			spin_speed: 0,
		}
	}
	
	pub fn step (&mut self, controller: &ControllerState) {
		const SPIN_RAMP_TIME: i32 = 30;
		
		let spin_f = 4.0 * self.spin_speed as f32 / SPIN_RAMP_TIME as f32;
		
		if controller.is_pressed (KEY_LEFT) {
			self.spin_speed = std::cmp::min (self.spin_speed + 1, SPIN_RAMP_TIME);
			self.azimuth += spin_f;
		}
		else if controller.is_pressed (KEY_RIGHT) {
			self.spin_speed = std::cmp::min (self.spin_speed + 1, SPIN_RAMP_TIME);
			self.azimuth -= spin_f;
		}
		else if controller.is_pressed (KEY_UP) {
			self.spin_speed = std::cmp::min (self.spin_speed + 1, SPIN_RAMP_TIME);
			self.altitude = f32::min (90.0, self.altitude + spin_f);
		}
		else if controller.is_pressed (KEY_DOWN) {
			self.spin_speed = std::cmp::min (self.spin_speed + 1, SPIN_RAMP_TIME);
			self.altitude = f32::max (-90.0, self.altitude - spin_f);
		}
		else {
			self.spin_speed = 0;
		}
	}
}

fn main () {
	let sdl_context = sdl2::init ().unwrap ();
	let video_subsystem = sdl_context.video ().unwrap ();
	
	let window = video_subsystem.window ("OpenGL? In my Rust?", 1280, 720)
		.position_centered ()
		.opengl ()
		.build ()
	.unwrap ();
	
	gl::load_with (|s| {
		let result = video_subsystem.gl_get_proc_address (s) as *const _;
		//println! ("{:?}", result);
		
		result
	});
	
	assert! (gl::ClearColor::is_loaded ());
	
	let gl_ctx = window.gl_create_context ().unwrap ();
	
	window.gl_make_current (&gl_ctx).unwrap ();
	
	// I love how with Rust I can throw unwrap ()s everywhere
	// It's safer than C / C++'s default behavior of unchecked errors
	// It's more programmer-friendly and explicit than C#'s unchecked
	// exceptions that can appear almost anywhere at runtime with no
	// compile-time warning
	// And I'm still not actually checking errors - Just checkmarking
	// that I know where they are.
	
	let vert_shader = ShaderObject::new (gl::VERTEX_SHADER, VERT_SHADER_SRC).unwrap ();
	let frag_shader = ShaderObject::new (gl::FRAGMENT_SHADER, FRAG_SHADER_SRC).unwrap ();
	
	let shader_program = ShaderProgram::new (&vert_shader, &frag_shader).unwrap ();
	
	let unis: HashMap <_, _> = vec! [
		"mvp",
		"object_space_light",
		"albedo",
		"min_albedo",
		"min_bright",
		"texture",
	].iter ()
	.map (|name| {
		let mut s = String::from ("uni_");
		s.push_str (name);
		
		let c_str = CString::new (s.as_bytes ()).unwrap ();
		let loc = shader_program.get_uniform_location (&c_str);
		
		println! ("Uni {} --> {}", name, loc);
		
		(String::from (*name), loc)
	})
	.collect ();
	
	let attrs: HashMap <_, Option <u32>> = vec! [
		"pos",
		"uv",
		"normal",
	].iter ()
	.map (|name| {
		let mut s = String::from ("attr_");
		s.push_str (name);
		
		let c_str = CString::new (s.as_bytes ()).unwrap ();
		let loc = shader_program.get_attribute_location (&c_str);
		let loc = match loc.try_into () {
			Ok (i) => Some (i),
			_ => {
				println! ("Attribute {} not found - Optimized out?", name);
				None
			},
		};
		
		(String::from (*name), loc)
	})
	.collect ();
	
	let texture = ugly_load_texture ("sky.png");
	
	let model_data = load_small_file ("pumpking.iqm");
	let model = IqmModel::from_slice (&model_data [..]);
	
	let sky_data = load_small_file ("sky-sphere.iqm");
	let sky_model = IqmModel::from_slice (&sky_data [..]);
	
	const FALSE_U8: u8 = 0;
	
	unsafe {
		enable_vertex_attrib_array (attrs ["pos"]);
		enable_vertex_attrib_array (attrs ["uv"]);
		enable_vertex_attrib_array (attrs ["normal"]);
		
		gl::Enable (gl::DEPTH_TEST);
		gl::Enable (gl::TEXTURE);
		
		let num_coords = 3;
		let stride = 4 * num_coords;
	}
	
	let mut last_frame_time = Instant::now ();
	let mut frame = 0;
	let mut timestep_accum = Duration::from_millis (0);
	
	let mut state = WorldState::new ();
	
	let mut event_pump = sdl_context.event_pump ().unwrap ();
	'running: loop {
		let frame_time = Instant::now ();
		
		// Take 60 steps every 1,000 milliseconds.
		// I know this is a float, but since we're multiplying it will
		// be deterministic, since it's a whole number.
		let fps_num = 60.0;
		let fps_den = 1000;
		
		timestep_accum += (frame_time - last_frame_time).mul_f32 (fps_num);
		
		let controller = ControllerState::from_sdl_keyboard (&event_pump.keyboard_state ());
		
		for _ in 0..4 {
			if timestep_accum > Duration::from_millis (fps_den) {
				frame += 1;
				timestep_accum -= Duration::from_millis (fps_den);
				
				state.step (&controller);
			}
			else {
				break;
			}
		}
		
		last_frame_time = frame_time;
		
		let _mouse = event_pump.mouse_state ();
		
		for event in event_pump.poll_iter() {
			match event {
				Event::Quit {..} |
				Event::KeyDown { keycode: Some (Keycode::Escape), .. } => {
					break 'running
				},
				_ => (),
			}
		}
		
		window.gl_make_current (&gl_ctx).unwrap ();
		
		//let longitude = (frame as f32).to_radians ();
		let longitude = state.azimuth.to_radians ();
		let latitude = (state.altitude - 90.0).to_radians ();
		//let latitude = (frame as f32 / 5.0).to_radians ().sin () * -40.0f32.to_radians () - 75.0f32.to_radians ();
		
		let proj_mat = Mat4::perspective_rh_gl (30.0f32.to_radians (), 1280.0 / 720.0, 0.5, 500.0);
		
		let model_mat = 
		Mat4::from_translation (Vec3::from ((0.0, 0.0, -2.7 * 0.5)))
		;
		
		let view_mat = proj_mat *
		Mat4::from_translation (Vec3::from ((0.0, 0.0, -8.0))) *
		Mat4::from_rotation_x (latitude) *
		Mat4::from_rotation_z (longitude)
		;
		
		let mvp_mat = view_mat * model_mat;
		
		let sky_mvp_mat = view_mat * Mat4::from_scale (Vec3::from ((16.0, 16.0, 16.0)));
		
		let light = Vec3::from ((2.0, 0.0, 5.0)).normalize ();
		let object_space_light = model_mat.inverse () * Vec4::from ((light.x (), light.y (), light.z (), 0.0));
		
		let orange = Vec3::from ((255.0 / 255.0, 154.0 / 255.0, 0.0 / 255.0));
		let green = Vec3::from ((14.0 / 255.0, 127.0 / 255.0, 24.0 / 255.0));
		let white = Vec3::from ((1.0, 1.0, 1.0));
		let black = Vec3::from ((0.0, 0.0, 0.0));
		
		let orange = orange * orange;
		let green = green * green;
		
		unsafe {
			gl::ClearColor (1.0f32, 1.0f32, 1.0f32, 1.0f32);
			gl::Clear (gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT);
			gl::Disable (gl::CULL_FACE);
			
			gl::Uniform3fv (unis ["min_bright"], 1, &black as *const Vec3 as *const f32);
			gl::Uniform3fv (unis ["min_albedo"], 1, &white as *const Vec3 as *const f32);
			
			gl::UniformMatrix4fv (unis ["mvp"], 1, FALSE_U8, &mvp_mat as *const Mat4 as *const f32);
			gl::Uniform3fv (unis ["object_space_light"], 1, &object_space_light as *const Vec4 as *const f32);
			
			gl::Uniform3fv (unis ["albedo"], 1, &orange as *const Vec3 as *const f32);
			
			point_to_model (&attrs, &model);
			
			gl::DrawElements (gl::TRIANGLES, (model.meshes [0].num_triangles * 3) as i32, gl::UNSIGNED_INT, &model.get_index_slice (0) [0] as *const u8 as *const c_void);
			
			if true {
				gl::Uniform3fv (unis ["albedo"], 1, &green as *const Vec3 as *const f32);
				
				gl::DrawElements (gl::TRIANGLES, (model.meshes [1].num_triangles * 3) as i32, gl::UNSIGNED_INT, &model.get_index_slice (1) [0] as *const u8 as *const c_void);
			}
			
			let draw_sky = true;
			if draw_sky {
				//println! ("Drawing sky");
				
				gl::UniformMatrix4fv (unis ["mvp"], 1, FALSE_U8, &sky_mvp_mat as *const Mat4 as *const f32);
				
				gl::Uniform3fv (unis ["albedo"], 1, &white as *const Vec3 as *const f32);
				gl::Uniform3fv (unis ["min_bright"], 1, &white as *const Vec3 as *const f32);
				gl::Uniform3fv (unis ["min_albedo"], 1, &black as *const Vec3 as *const f32);
				gl::Uniform1i (unis ["texture"], 0);
				
				point_to_model (&attrs, &sky_model);
				
				gl::DrawElements (gl::TRIANGLES, (sky_model.meshes [0].num_triangles * 3) as i32, gl::UNSIGNED_INT, &sky_model.get_index_slice (0) [0] as *const u8 as *const c_void);
			}
		}
		
		window.gl_swap_window ();
		
		::std::thread::sleep (Duration::from_millis (15));
	}
}

#[cfg (test)]
mod tests {
	use super::*;
	
	#[test]
	pub fn iqm () {
		let data = load_small_file ("pumpking.iqm");
		
		{
			let model = IqmHeader::from_slice (&data [..]).unwrap ().1;
			
			assert_eq! (model.fields [1], 90368);
			assert_eq! (model.fields [2], 0);
			assert_eq! (model.fields [iqm_consts::VERSION], 2);
		}
		
		{
			let model = IqmModel::from_slice (&data [..]);
			
			println! ("{:?}", model.meshes);
			println! ("{:?}", model.vertexarrays);
		}
	}
}