refactor view/scene to separate modules

src/view.rs

@@ -0,0 +1,111 @@
+use scenes;
+use vr;
+use vr::{AsMatrix4, VR};
+
+extern crate gfx_device_gl;
+extern crate nalgebra as na;
+extern crate num_traits;
+extern crate piston_window;
+
+use gfx;
+use gfx::Device;
+use gfx::traits::FactoryExt;
+use self::na::Inverse;
+use self::num_traits::identities::One;
+use self::piston_window::{PistonWindow, Window};
+
+pub type ColorFormat = gfx::format::Srgba8;
+pub type DepthFormat = gfx::format::DepthStencil;
+
+const NEAR: f32 = 0.01;
+const FAR: f32 = 1000.0;
+
+gfx_constant_struct! {
+  Trans {
+    matrix: [[f32; 4]; 4] = "u_matrix",
+  }
+}
+
+pub struct ViewRoot<Dev, T, D>
+  where Dev: gfx::Device,
+        T: gfx::format::RenderFormat + gfx::format::TextureFormat,
+        D: gfx::format::DepthFormat + gfx::format::TextureFormat {
+
+  left: vr::EyeBuffer<T, D>,
+  right: vr::EyeBuffer<T, D>,
+  trans: gfx::handle::Buffer<Dev::Resources, Trans>,
+  scene: Box<::scene::Scene<Dev, gfx_device_gl::Factory>>,
+}
+
+impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
+  pub fn create_view(window: &mut PistonWindow, vr: &VR)
+                     -> ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
+
+    let render_size = vr.recommended_render_target_size();
+    let left = vr::create_eyebuffer(&mut window.factory, render_size)
+        .expect("create left renderbuffer");
+    let right = vr::create_eyebuffer(&mut window.factory, render_size)
+        .expect("create right renderbuffer");
+    let trans = window.factory.create_constant_buffer(1);
+
+    window.window.swap_buffers(); // To contain setup calls to Frame 0 in apitrace
+
+    ViewRoot::<gfx_device_gl::Device, ColorFormat, DepthFormat> {
+      left: left,
+      right: right,
+      trans: trans.clone(),
+      scene: Box::new(scenes::world::WorldScene::new(&mut window.factory, &trans)),
+    }
+  }
+
+  pub fn draw(&self,
+              window: &mut PistonWindow,
+              vr: &mut vr::VR) {
+    // Get the current sensor state
+    let poses = vr.poses();
+
+    let mut hmd_mat = poses.poses[0].to_device.as_matrix4();
+    hmd_mat.inverse_mut();
+
+    for &(eye, buffers) in [(vr::Eye::Left, &self.left),
+                            (vr::Eye::Right, &self.right)].into_iter() {
+      window.encoder.clear(&buffers.target, [0.1, 0.2, 0.3, 1.0]);
+
+      window.encoder.clear_depth(&buffers.depth, 1.0);
+
+        // Submit eye textures
+      let proj_mat = vr.projection_matrix(eye, NEAR, FAR);
+      let eye_mat = vr.head_to_eye_transform(eye);
+      for track in (0..poses.count).map(|pose| poses.poses[pose]) {
+        match track.device_class() {
+          vr::TrackedDeviceClass::Controller |
+          vr::TrackedDeviceClass::TrackingReference => {
+            let model_mat = track.to_device.as_matrix4();
+
+            let trans = Trans { matrix: *(proj_mat * eye_mat * hmd_mat * model_mat).as_ref() };
+            window.encoder.update_constant_buffer(&self.trans, &trans);
+
+            self.scene.render(&mut window.factory,
+                              &mut window.encoder,
+                              &buffers.target,
+                              &buffers.depth);
+          },
+          _ => ()
+        }
+      }
+
+    }
+    // draw monitor window
+    window.encoder.update_constant_buffer(&self.trans,
+                                          &Trans { matrix: *na::Matrix4::one().as_ref() });
+    window.encoder.clear(&window.output_color, [0.1, 0.2, 0.3, 1.0]);
+    window.encoder.clear_depth(&window.output_stencil, 1.0);
+    self.scene.render(&mut window.factory, &mut window.encoder, &window.output_color, &window.output_stencil);
+
+    window.encoder.flush(&mut window.device);
+    vr.submit(vr::Eye::Left, &self.left.tex);
+    vr.submit(vr::Eye::Right, &self.right.tex);
+    window.window.swap_buffers();
+    window.device.cleanup();
+  }
+}