Add a sea shaded cubes, just because. No big deal (yet).
[mandelwow.git] / support / camera.rs
1 extern crate glutin;
2
3 use glutin::ElementState::{Pressed, Released};
4 use glutin::Event::{KeyboardInput, MouseMoved};
5 use glutin::VirtualKeyCode;
6 use support::vec3::Vec3;
7 use support::vec3::norm;
8
9 use std::f32;
10
11 //use glutin::Event;
12 //use VirtualKeyCode;
13
14 #[derive(Default)]
15 pub struct CameraState {
16     aspect_ratio: f32,
17     pos: Vec3,
18     dir: Vec3,
19
20     moving_up: bool,
21     moving_left: bool,
22     moving_down: bool,
23     moving_right: bool,
24     moving_forward: bool,
25     moving_backward: bool,
26     turning_up: bool,
27     turning_left: bool,
28     turning_down: bool,
29     turning_right: bool,
30
31     mouse_x: i32,
32     mouse_y: i32,
33     rel_x: i32,
34     rel_y: i32,
35 }
36
37 impl CameraState {
38     pub fn new() -> CameraState {
39         CameraState {
40             aspect_ratio: 600.0 / 600.0,
41             pos: Vec3(0.0, 0.0, 0.0),
42             dir: Vec3(0.0, 0.0, -1.0),
43             .. Default::default()
44         }
45     }
46
47     pub fn set_pos(&mut self, pos: Vec3) {
48         self.pos = pos;
49     }
50
51     pub fn get_pos(&self) -> Vec3 {
52         self.pos
53     }
54
55     pub fn set_dir(&mut self, dir: Vec3) {
56         self.dir = dir;
57     }
58
59     pub fn get_perspective(&self) -> [[f32; 4]; 4] {
60         let fov: f32 = 3.141592 / 2.0;
61         let zfar = 1024.0;
62         let znear = 0.1;
63
64         let f = 1.0 / (fov / 2.0).tan();
65
66         // note: remember that this is column-major, so the lines of code are actually columns
67         [
68             [f / self.aspect_ratio,    0.0,              0.0              ,   0.0],
69             [         0.0         ,     f ,              0.0              ,   0.0],
70             [         0.0         ,    0.0,  (zfar+znear)/(zfar-znear)    ,   1.0],
71             [         0.0         ,    0.0, -(2.0*zfar*znear)/(zfar-znear),   0.0],
72         ]
73     }
74
75     pub fn get_view(&self) -> [[f32; 4]; 4] {
76         let f = norm(&self.dir);
77
78         let up = Vec3(0.0, 1.0, 0.0);
79
80         let s = Vec3(f.1 * up.2 - f.2 * up.1,
81                      f.2 * up.0 - f.0 * up.2,
82                      f.0 * up.1 - f.1 * up.0);
83         let sn = norm(&s);
84
85         let u = (sn.1 * f.2 - sn.2 * f.1,
86                  sn.2 * f.0 - sn.0 * f.2,
87                  sn.0 * f.1 - sn.1 * f.0);
88
89         let p = (-self.pos.0 * s.0 - self.pos.1 * s.1 - self.pos.2 * s.2,
90                  -self.pos.0 * u.0 - self.pos.1 * u.1 - self.pos.2 * u.2,
91                  -self.pos.0 * f.0 - self.pos.1 * f.1 - self.pos.2 * f.2);
92
93         // note: remember that this is column-major, so the lines of code are actually columns
94         [
95             [sn.0, u.0, f.0, 0.0],
96             [sn.1, u.1, f.1, 0.0],
97             [sn.2, u.2, f.2, 0.0],
98             [p.0,  p.1, p.2, 1.0],
99         ]
100     }
101
102     pub fn update(&mut self) {
103         let f = norm(&self.dir);
104
105         let up = Vec3(0.0, 1.0, 0.0);
106
107         let s = Vec3(f.1 * up.2 - f.2 * up.1,
108                      f.2 * up.0 - f.0 * up.2,
109                      f.0 * up.1 - f.1 * up.0);
110
111         let s = norm(&s);
112
113         let u = Vec3(s.1 * f.2 - s.2 * f.1,
114                      s.2 * f.0 - s.0 * f.2,
115                      s.0 * f.1 - s.1 * f.0);
116
117         let walk_speed = 0.01;
118         let strife_speed = 0.02;
119         let pan_speed = 0.01;
120
121         if self.moving_up {
122             self.pos += u * strife_speed;
123         }
124         if self.moving_down {
125             self.pos -= u * strife_speed;
126         }
127         if self.moving_left {
128             self.pos -= s * strife_speed;
129         }
130         if self.moving_right {
131             self.pos += s * strife_speed;
132         }
133         if self.moving_forward {
134             self.pos += f * walk_speed;
135         }
136         if self.moving_backward {
137             self.pos -= f * walk_speed;
138         }
139
140         if self.turning_left { self.rel_x -= 2; }
141         if self.turning_right { self.rel_x += 2; }
142         if self.turning_up { self.rel_y -= 2; }
143         if self.turning_down { self.rel_y += 2; }
144         let vx = -pan_speed * self.rel_x as f32;
145         let vy = -pan_speed * self.rel_y as f32;
146         self.dir = Vec3(f.0 * vx.cos() + f.2 * vx.sin(),
147                         f.1 * vy.cos() - f.2 * vy.sin(),
148                         f.1 * vy.sin() - f.0 * vx.sin() + f.2 * vx.cos() * vy.cos());
149         self.rel_x = 0;
150         self.rel_y = 0;
151
152         //println!("camera_pos = {:?}", self.pos);
153         //println!("camera_dir = {:?}", self.dir);
154     }
155
156     pub fn process_input(&mut self, event: &glutin::Event) {
157         match event {
158             &MouseMoved(x, y) => {
159                 self.rel_x += x - self.mouse_x;
160                 self.rel_y += y - self.mouse_y;
161                 self.mouse_x = x;
162                 self.mouse_y = y;
163             }
164             &KeyboardInput(Pressed, _, Some(VirtualKeyCode::Up)) => {
165                 self.moving_up = true;
166             },
167             &KeyboardInput(Released, _, Some(VirtualKeyCode::Up)) => {
168                 self.moving_up = false;
169             },
170             &KeyboardInput(Pressed, _, Some(VirtualKeyCode::Down)) => {
171                 self.moving_down = true;
172             },
173             &KeyboardInput(Released, _, Some(VirtualKeyCode::Down)) => {
174                 self.moving_down = false;
175             },
176             &KeyboardInput(Pressed, _, Some(VirtualKeyCode::Left)) => {
177                 self.moving_left = true;
178             },
179             &KeyboardInput(Released, _, Some(VirtualKeyCode::Left)) => {
180                 self.moving_left = false;
181             },
182             &KeyboardInput(Pressed, _, Some(VirtualKeyCode::Right)) => {
183                 self.moving_right = true;
184             },
185             &KeyboardInput(Released, _, Some(VirtualKeyCode::Right)) => {
186                 self.moving_right = false;
187             },
188             &KeyboardInput(Pressed, _, Some(VirtualKeyCode::A)) => {
189                 self.turning_left = true;
190             },
191             &KeyboardInput(Released, _, Some(VirtualKeyCode::A)) => {
192                 self.turning_left = false;
193             },
194             &KeyboardInput(Pressed, _, Some(VirtualKeyCode::D)) => {
195                 self.turning_right = true;
196             },
197             &KeyboardInput(Released, _, Some(VirtualKeyCode::D)) => {
198                 self.turning_right = false;
199             },
200             &KeyboardInput(Pressed, _, Some(VirtualKeyCode::W)) => {
201                 self.moving_forward = true;
202             },
203             &KeyboardInput(Released, _, Some(VirtualKeyCode::W)) => {
204                 self.moving_forward = false;
205             },
206             &KeyboardInput(Pressed, _, Some(VirtualKeyCode::S)) => {
207                 self.moving_backward = true;
208             },
209             &KeyboardInput(Released, _, Some(VirtualKeyCode::S)) => {
210                 self.moving_backward = false;
211             },
212             &KeyboardInput(Pressed, _, Some(VirtualKeyCode::R)) => {
213                 self.turning_up = true;
214             },
215             &KeyboardInput(Released, _, Some(VirtualKeyCode::R)) => {
216                 self.turning_up = false;
217             },
218             &KeyboardInput(Pressed, _, Some(VirtualKeyCode::F)) => {
219                 self.turning_down = true;
220             },
221             &KeyboardInput(Released, _, Some(VirtualKeyCode::F)) => {
222                 self.turning_down = false;
223             },
224             _ => {}
225         }
226     }
227 }