2021-32-bit-holiday-jam/src/bin/pumpkin.rs

use glam::{Mat4, Vec3, Vec4};
use rand::Rng;

use sdl2::event::Event;
use sdl2::keyboard::{Keycode, Scancode};
use std::collections::*;
use std::iter::FromIterator;
use std::str;
use std::time::{Duration};

use opengl_rust::*;

use file::load_small_file;
use iqm::Model;
use renderable_model::RenderableModel;
use shader::{ShaderProgram, ShaderObject};
use texture::Texture;
use timestep::TimeStep;

pub fn color_from_255 <V> (rgb: V) -> Vec3
where V: Into <Vec3>
{
	let rgb: Vec3 = rgb.into ();
	
	Vec3::from ((
		rgb.x () / 255.0,
		rgb.y () / 255.0,
		rgb.z () / 255.0
	))
}

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;

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;
		}
	}
}

mod uniforms {
use iota::iota;
iota! {
	pub const MVP: u32 = iota;
	        , OBJECT_SPACE_LIGHT
	        , OBJECT_SPACE_SKY
	        , ALBEDO
	        , MIN_ALBEDO
	        , MIN_BRIGHT
	        , TEXTURE
	        , DITHER_PHASE
}
}

fn make_object_space_vec (inverse_model_mat: &Mat4, world_space_vec: &Vec3)
-> Vec3
{
	let v = world_space_vec;
	let v4 = *inverse_model_mat * Vec4::from ((v.x (), v.y (), v.z (), 0.0));
	Vec3::from ((v4.x (), v4.y (), v4.z ()))
}

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| {
		video_subsystem.gl_get_proc_address (s) as *const _
	});
	
	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 shader_program = {
		let vert_shader = ShaderObject::from_file (gl::VERTEX_SHADER, "shaders/pumpkin-vert.glsl").unwrap ();
		let frag_shader = ShaderObject::from_file (gl::FRAGMENT_SHADER, "shaders/pumpkin-frag.glsl").unwrap ();
		
		ShaderProgram::new (&vert_shader, &frag_shader).unwrap ()
	};
	
	let shadow_shader = {
		let vert_shader = ShaderObject::from_file (gl::VERTEX_SHADER, "shaders/shadow-vert.glsl").unwrap ();
		let frag_shader = ShaderObject::from_file (gl::FRAGMENT_SHADER, "shaders/shadow-frag.glsl").unwrap ();
		
		ShaderProgram::new (&vert_shader, &frag_shader).unwrap ()
	};
	
	let uni_lookup: HashMap <_, &str> = HashMap::from_iter ({
		use uniforms::*;
		vec! [
			(MVP, "mvp"),
			(OBJECT_SPACE_LIGHT, "object_space_light"),
			(OBJECT_SPACE_SKY, "object_space_sky"),
			(ALBEDO, "albedo"),
			(MIN_ALBEDO, "min_albedo"),
			(MIN_BRIGHT, "min_bright"),
			(TEXTURE, "texture"),
			(DITHER_PHASE, "dither_phase"),
		].into_iter ()
	});
	
	let unis = {
		let unis = shader_program.get_uniform_locations (uni_lookup.values ().copied ());
		
		let unis: HashMap <u32, i32> = HashMap::from_iter (
			uni_lookup.iter ()
			.map (|(key, name)| (*key, *unis.get (*name).unwrap ()))
		);
		unis
	};
	
	let shadow_unis = {
		let unis = shadow_shader.get_uniform_locations (uni_lookup.values ().copied ());
		
		let unis: HashMap <u32, i32> = HashMap::from_iter (
			uni_lookup.iter ()
			.map (|(key, name)| (*key, *unis.get (*name).unwrap ()))
		);
		unis
	};
	
	let attrs = shader_program.get_attribute_locations (vec! [
		"pos",
		"uv",
		"normal",
	].into_iter ());
	
	let shadow_attrs = shadow_shader.get_attribute_locations (vec! [
		"pos",
		"uv",
		"normal",
	].into_iter ());
	
	let texture = Texture::from_file ("sky.png");
	texture.bind ();
	
	let model_data = load_small_file ("pumpking.iqm", 1024 * 1024);
	let model = Model::from_slice (&model_data);
	
	let renderable_model = RenderableModel::from_iqm (&model);
	
	let sky_data = load_small_file ("sky-sphere.iqm", 1024 * 1024);
	let sky_model = Model::from_slice (&sky_data);
	
	let renderable_sky = RenderableModel::from_iqm (&sky_model);
	
	let (renderable_pitch, pitch_colors, grass_index) = {
		let data = load_small_file ("pitch.iqm", 1024 * 1024);
		let model = Model::from_slice (&data);
		
		let silver = (255.0, 255.0, 255.0);
		let wood = (133.0, 76.0, 48.0);
		
		let color_lookup: HashMap <&str, _> = HashMap::from_iter (vec! [
			("GoalN1", silver),
			("GoalN2", silver),
			("GoalN3", silver),
			
			("GoalS1", silver),
			("GoalS2", silver),
			("GoalS3", silver),
			
			("TowerNW", wood),
			("TowerNE", wood),
			("TowerSW", wood),
			("TowerSE", wood),
			
			("Wall", wood),
			
			("Grass", (52.0, 101.0, 36.0)),
		].into_iter ());
		
		let mut grass_index = None;
		let colors: Vec <_> = (0..model.meshes.len ()).map (|i| {
			let name = str::from_utf8 (model.get_mesh_name (i)).unwrap ();
			if name == "Grass" {
				grass_index = Some (i);
			}
			
			match color_lookup.get (name) {
				Some (t) => color_from_255 (*t),
				_ => (0.0, 0.0, 0.0).into (),
			}
		}).collect ();
		
		(RenderableModel::from_iqm (&model), colors, grass_index.unwrap ())
	};
	
	glezz::enable_vertex_attrib_array (attrs ["pos"]);
	glezz::enable_vertex_attrib_array (attrs ["uv"]);
	glezz::enable_vertex_attrib_array (attrs ["normal"]);
	
	glezz::enable (gl::DEPTH_TEST);
	glezz::enable (gl::TEXTURE_2D);
	
	let mut time_step = TimeStep::new (60, 1000);
	let mut state = WorldState::new ();
	
	let mut event_pump = sdl_context.event_pump ().unwrap ();
	'running: loop {
		let frames_to_do = time_step.step ();
		
		let controller = ControllerState::from_sdl_keyboard (&event_pump.keyboard_state ());
		
		for _ in 0..frames_to_do {
			state.step (&controller);
		}
		
		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 dither_phase = rand::thread_rng ().gen_range (0, 16);
		
		let longitude = state.azimuth.to_radians ();
		let latitude = (state.altitude - 90.0).to_radians ();
		
		let proj_mat = Mat4::perspective_rh_gl (30.0f32.to_radians (), 1280.0 / 720.0, 0.5, 500.0);
		
		let shadow_mat = {
			let mut mat = Mat4::identity ();
			mat.set_z_axis ((0.25, 0.125, 0.0, 0.0).into ());
			mat
		};
		
		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) *
		Mat4::from_translation ((0.0, 0.0, -2.7 * 0.5).into ())
		;
		
		let sky_mvp_mat = view_mat * Mat4::from_scale ((16.0, 16.0, 16.0).into ());
		
		let light = Vec3::from ((2.0, 0.0, 5.0)).normalize ();
		//let light = Vec3::from ((0.0, 0.0, 0.0)).normalize ();
		
		let orange = color_from_255 ((210.0, 125.0, 44.0));
		let green = color_from_255 ((52.0, 101.0, 36.0));
		let white = color_from_255 ((255.0, 255.0, 255.0));
		let _off_white = color_from_255 ((222.0, 238.0, 214.0));
		let black = color_from_255 ((0.0, 0.0, 0.0));
		let _off_black = color_from_255 ((20.0, 12.0, 28.0));
		
		glezz::clear_color (1.0f32, 0.0f32, 1.0f32, 1.0f32);
		glezz::clear (gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT | gl::STENCIL_BUFFER_BIT);
		glezz::enable (gl::CULL_FACE);
		
		let pumpkin_model_mat = 
		Mat4::from_translation ((0.0, 0.0, 2.7 * 0.5).into ()) *
		Mat4::from_scale ((0.125, 0.125, 0.125).into ()) *
		Mat4::from_translation ((0.0, 0.0, -2.7 * 0.5).into ())
		;
		
		let world_model_mat = Mat4::identity ();
		
		{
			use uniforms::*;
			
			shader_program.use_program ();
			glezz::disable (gl::STENCIL_TEST);
			glezz::front_face (gl::CW);
			
			let mvp = view_mat * pumpkin_model_mat;
			glezz::uniform_matrix_4fv (unis [&MVP], &mvp);
			
			let inverse_pumpkin = pumpkin_model_mat.inverse ();
			
			let object_space_light = make_object_space_vec (&inverse_pumpkin, &light);
			
			let object_space_sky = make_object_space_vec (&inverse_pumpkin, &Vec3::from ((0.0, 0.0, 1.0)));
			
			glezz::uniform_3fv (unis [&MIN_BRIGHT], &black);
			glezz::uniform_3fv (unis [&MIN_ALBEDO], &white);
			glezz::uniform_3fv (unis [&OBJECT_SPACE_LIGHT], &object_space_light);
			glezz::uniform_3fv (unis [&OBJECT_SPACE_SKY], &object_space_sky);
			
			{
				glezz::uniform_3fv (unis [&ALBEDO], &orange);
				renderable_model.draw (&attrs, 0);
				
				glezz::uniform_3fv (unis [&ALBEDO], &green);
				renderable_model.draw (&attrs, 1);
			}
			
			let mvp = view_mat * world_model_mat;
			glezz::uniform_matrix_4fv (unis [&MVP], &mvp);
			
			for (i, color) in pitch_colors.iter ().enumerate ().take (renderable_pitch.num_meshes ())
			{
				glezz::uniform_3fv (unis [&ALBEDO], color);
				if i != grass_index {
					renderable_pitch.draw (&attrs, i);
				}
			}
			
			let draw_sky = true;
			if draw_sky {
				glezz::front_face (gl::CCW);
				glezz::uniform_matrix_4fv (unis [&MVP], &sky_mvp_mat);
				glezz::uniform_3fv (unis [&ALBEDO], &white);
				glezz::uniform_3fv (unis [&MIN_BRIGHT], &white);
				glezz::uniform_3fv (unis [&MIN_ALBEDO], &black);
				glezz::uniform_1i (unis [&TEXTURE], 0);
				
				renderable_sky.draw (&attrs, 0);
			}
			
			glezz::enable (gl::STENCIL_TEST);
			unsafe {
				gl::StencilFunc (gl::ALWAYS, 1, 1);
				gl::StencilOp (gl::KEEP, gl::KEEP, gl::REPLACE);
				
				gl::ColorMask (0, 0, 0, 0);
				gl::DepthMask (0);
				gl::StencilMask (1);
			}
			shadow_shader.use_program ();
			
			let view_mat = view_mat * shadow_mat;
			
			let mvp = view_mat * pumpkin_model_mat;
			glezz::uniform_matrix_4fv (shadow_unis [&MVP], &mvp);
			
			{
				renderable_model.draw (&shadow_attrs, 0);
				renderable_model.draw (&shadow_attrs, 1);
			}
			
			let mvp = view_mat * world_model_mat;
			glezz::uniform_matrix_4fv (shadow_unis [&MVP], &mvp);
			
			for i in 0..renderable_pitch.num_meshes () {
				if i != grass_index {
					renderable_pitch.draw (&shadow_attrs, i);
				}
			}
			
			unsafe {
				gl::ColorMask (255, 255, 255, 255);
				gl::DepthMask (1);
			}
			shader_program.use_program ();
			glezz::front_face (gl::CW);
			
			let inverse_pumpkin = pumpkin_model_mat.inverse ();
			
			let object_space_light = make_object_space_vec (&inverse_pumpkin, &light);
			
			let object_space_sky = make_object_space_vec (&inverse_pumpkin, &Vec3::from ((0.0, 0.0, 1.0)));
			
			glezz::uniform_3fv (unis [&MIN_BRIGHT], &black);
			glezz::uniform_3fv (unis [&MIN_ALBEDO], &white);
			glezz::uniform_3fv (unis [&OBJECT_SPACE_SKY], &object_space_sky);
			
			let mvp = view_mat * world_model_mat;
			glezz::uniform_matrix_4fv (unis [&MVP], &mvp);
			
			glezz::uniform_3fv (unis [&ALBEDO], &pitch_colors [grass_index]);
			
			unsafe {
				gl::StencilFunc (gl::NOTEQUAL, 0, 1);
				gl::StencilOp (gl::KEEP, gl::KEEP, gl::KEEP);
			}
			glezz::uniform_3fv (unis [&OBJECT_SPACE_LIGHT], &Vec3::from ((0.0, 0.0, 0.0)));
			renderable_pitch.draw (&attrs, grass_index);
			
			unsafe {
				gl::StencilFunc (gl::EQUAL, 0, 1);
				gl::StencilOp (gl::KEEP, gl::KEEP, gl::KEEP);
			}
			glezz::uniform_3fv (unis [&OBJECT_SPACE_LIGHT], &object_space_light);
			renderable_pitch.draw (&attrs, grass_index);
		}
		
		window.gl_swap_window ();
		
		std::thread::sleep (Duration::from_millis (15));
	}
}

#[cfg (test)]
mod tests {
	use super::*;
	
	#[test]
	pub fn iqm () {
		
	}
}