2 files changed, 102 insertions, 11 deletions

diff --git a/examples/render-bsp/data/test.bsp b/examples/render-bsp/data/test.bsp
index 484f5b1..2aa0334 100644
--- a/examples/render-bsp/data/test.bsp
+++ b/examples/render-bsp/data/test.bsp
diff --git a/examples/render-bsp/src/main.rs b/examples/render-bsp/src/main.rs
index 8116bd5..7477567 100644
--- a/examples/render-bsp/src/main.rs
+++ b/examples/render-bsp/src/main.rs
@@ -20,49 +20,140 @@ extern crate stockton_bsp;
 extern crate stockton_render;
 extern crate winit;
 extern crate simple_logger;
+extern crate image;
 
-use std::fs::File;
-use std::io::Read;
+use image::load_from_memory;
+use std::time::SystemTime;
 
 use stockton_bsp::BSPFile;
-use stockton_types::World;
+use stockton_types::{World, Vector3};
 use stockton_render::Renderer;
 
 use winit::{
-    event::{Event, WindowEvent},
+    event::{Event, WindowEvent, ElementState},
     event_loop::{ControlFlow, EventLoop},
     window::WindowBuilder
 };
 
+const SPEED: f32 = 25.0;
+
+#[derive(Debug)]
+struct KeyState {
+	pub up: bool,
+	pub left: bool,
+	pub right: bool,
+	pub down: bool,
+	pub inwards: bool,
+	pub out: bool
+}
+
+impl KeyState {
+	pub fn new() -> KeyState {
+		KeyState {
+			up: false,
+			left: false,
+			right: false,
+			down: false,
+			inwards: false,
+			out: false,
+		}
+	}
+
+	pub fn as_vector(&self) -> Vector3 {
+		let mut vec = Vector3::new(0.0, 0.0, 0.0);
+
+		if self.up {
+			vec.y = 1.0;
+		} else if self.down {
+			vec.y = -1.0;
+		}
+
+		if self.right {
+			vec.x = 1.0;
+		} else if self.left {
+			vec.x = -1.0;
+		}
+
+		if self.inwards {
+			vec.z = 1.0;
+		} else if self.out {
+			vec.z = -1.0;
+		}
+
+		vec
+	}
+}
+
 fn main() {
 	simple_logger::init().unwrap();
 
 	// Load the world and renderer
 	let event_loop = EventLoop::new();
 	let window = WindowBuilder::new().build(&event_loop).unwrap();
-	let data = include_bytes!("../data/test.bsp");
+	let data = include_bytes!("../data/test.bsp").to_vec().into_boxed_slice();
 	let bsp = BSPFile::from_buffer(data).unwrap();
-	println!("{:?}", bsp);
+	
 	let world = World::new(bsp).unwrap();
 	let mut renderer = Renderer::new(world, &window).unwrap();
 
+
+	renderer.context.add_texture(
+		load_from_memory(include_bytes!("../../render-quad/data/test1.png"))
+			.expect("Couldn't load test texture 1")
+			.into_rgba()).unwrap();
+
+	renderer.context.add_texture(
+		load_from_memory(include_bytes!("../../render-quad/data/test2.png"))
+			.expect("Couldn't load test texture 2")
+			.into_rgba()).unwrap();
+
+	let mut last_update = SystemTime::now();
+	let mut key_state = KeyState::new();
+
 	// Keep rendering the world
 	event_loop.run(move |event, _, flow| {
 		*flow = ControlFlow::Poll;
 		
 		match event {
-			// TODO: Handle resize
 			Event::WindowEvent {
-				event: WindowEvent::CloseRequested,
+				event,
 				..
-			} => {
-				*flow = ControlFlow::Exit
+			} => match event {
+				WindowEvent::CloseRequested => {
+					*flow = ControlFlow::Exit
+				},
+				WindowEvent::KeyboardInput {input, ..} => match input.scancode {
+					// Left
+					105 => key_state.left = input.state == ElementState::Pressed,
+					// Right
+					106 => key_state.right = input.state == ElementState::Pressed,
+					// Up (in)
+					103 => key_state.inwards = input.state == ElementState::Pressed,
+					// Down (out)
+					108 => key_state.out = input.state == ElementState::Pressed,
+					// Space (up)
+					57 => key_state.up = input.state == ElementState::Pressed,
+					// Ctrl (down)
+					29 => key_state.down = input.state == ElementState::Pressed,
+					_ => ()
+				}
+				_ => ()
 			},
 
 			Event::MainEventsCleared => {
 				window.request_redraw()
 			},
-			Event::RedrawRequested(_) => {		
+			Event::RedrawRequested(_) => {
+
+				let delta = last_update.elapsed().unwrap().as_secs_f32();
+				last_update = SystemTime::now();
+
+				let delta_pos = key_state.as_vector() * delta * SPEED;
+				if delta_pos.x != 0.0 || delta_pos.y != 0.0 || delta_pos.z != 0.0 {
+					renderer.context.move_camera(delta_pos);
+					println!("camera is at {:?}", renderer.context.camera_pos());
+				}
+
 				renderer.render_frame().unwrap()
 			}
 			_ => ()