commiting year-stale working dir for backup

Cargo.toml

@@ -14,7 +14,7 @@ gfx = "*"
 gfx_device_gl = "*"
 image = "*"
 lzw = "*"
-nalgebra = "*"
+nalgebra = "0.10"
 num-traits = "*"
 openvr = { git = "https://github.com/rust-openvr/rust-openvr" }
 openvr_sys = "*"

src/bin/init.rs

@@ -0,0 +1,15 @@
+extern crate openvr_sys;
+
+use openvr_sys::EVRInitError::*;
+use openvr_sys::EVRApplicationType::*;
+
+fn main() {
+  unsafe {
+    let mut err_arr = [EVRInitError_VRInitError_None; 16];
+    let err = std::mem::transmute(&mut err_arr);
+    let app_type = EVRApplicationType_VRApplication_Scene;
+
+    openvr_sys::VR_InitInternal(err, app_type);
+  };
+
+}

src/bin/poserelay.rs

@@ -0,0 +1,135 @@
+extern crate vrtue;
+use vrtue::vr;
+
+extern crate byteorder;
+extern crate env_logger;
+extern crate gfx;
+#[macro_use] extern crate log;
+extern crate openvr;
+extern crate openvr_sys;
+extern crate piston_window;
+
+use std::env;
+use std::mem::size_of;
+use std::net::UdpSocket;
+use std::io::Write;
+use self::byteorder::{LittleEndian, WriteBytesExt};
+
+use self::piston_window::{PistonWindow, Window, WindowSettings};
+
+pub type ColorFormat = gfx::format::Srgba8;
+pub type DepthFormat = gfx::format::DepthStencil;
+
+pub fn main() {
+  let mut vr = vr::VR::new().expect("VR init");
+  let args: Vec<String> = env::args().collect();
+
+  if args.len() != 2 {
+    println!("usage: {} <socketaddr>", args[0]);
+    return;
+  }
+
+  let udp_socket = UdpSocket::bind("0.0.0.0:0").expect("binding UDP socket");
+
+  let mut window: PistonWindow =
+    WindowSettings::new("Controller Pose Relay", [512; 2])
+    .exit_on_esc(true)
+    .vsync(false)
+    .build().expect("Building Window");
+
+  let render_size = vr.recommended_render_target_size();
+  let left: vr::EyeBuffer<ColorFormat, DepthFormat> = vr::create_eyebuffer(&mut window.factory, render_size)
+    .expect("create left renderbuffer");
+  let right: vr::EyeBuffer<ColorFormat, DepthFormat> = vr::create_eyebuffer(&mut window.factory, render_size)
+    .expect("create right renderbuffer");
+  window.encoder.clear(&left.target, [1.0, 0.0, 0.0, 1.0]);
+  window.encoder.clear_depth(&left.depth, 1.0);
+  window.encoder.clear(&right.target, [0.0, 1.0, 0.0, 1.0]);
+  window.encoder.clear_depth(&right.depth, 1.0);
+  window.encoder.flush(&mut window.device);
+
+  let mut pads = ::std::collections::BTreeMap::<_, Option<openvr_sys::VRControllerState_t>>::new();
+  let mut iteration = 0u64;
+  let mut udp_buffer = Vec::<u8>::with_capacity(size_of::<u64>() + size_of::<[[f32; 4]; 3]>());
+  'main: loop {
+    let poses = vr.poses();
+    vr.submit(vr::Eye::Left, &left.tex);
+    vr.submit(vr::Eye::Right, &right.tex);
+
+    for pose in poses.poses.iter() {
+      match pose.device_class() {
+        openvr::tracking::TrackedDeviceClass::Controller => {
+          udp_buffer.write_u64::<LittleEndian>(iteration).expect("buffering iter number");
+          for outer in pose.to_device.iter() {
+            for inner in outer {
+              udp_buffer.write_f32::<LittleEndian>(*inner).expect("buffering pose matrix element");
+            }
+          }
+          udp_buffer.flush().expect("flushing buffer");
+          udp_socket.send_to(&udp_buffer, &args[1][..]).expect("sending data");
+          if iteration % 90 == 0 {
+            println!("\nPOSE: {:?}", pose.to_device);
+            println!(" BUF: {:?}", udp_buffer);
+          }
+          break;
+        },
+        _ => continue
+      }
+    }
+    iteration += 1;
+    udp_buffer.clear();
+
+    while let Some(ev) = vr.poll_next_event() {
+      match ev {
+        vr::Event::Press { dev_idx, controller } => {
+          println!("Press event on #{}: {:?}", dev_idx, controller);
+        },
+        vr::Event::Unpress { dev_idx, controller } => {
+          println!("Unpress event on #{}: {:?}", dev_idx, controller);
+        },
+        vr::Event::Touch { dev_idx, controller } => {
+          if controller.button == openvr_sys::EVRButtonId_k_EButton_SteamVR_Touchpad as u32 {
+            pads.insert(dev_idx, None);
+          }
+          println!("Touch event on #{}: {:?}", dev_idx, controller);
+        },
+        vr::Event::Untouch { dev_idx, controller } => {
+          if controller.button == openvr_sys::EVRButtonId_k_EButton_SteamVR_Touchpad as u32 {
+            pads.remove(&dev_idx);
+          }
+          println!("Untouch event on #{}: {:?}", dev_idx, controller);
+        },
+        /*
+        t if t == openvr_sys::EVREventType::EVREventType_VREvent_TouchPadMove as u32 => {
+          let touch;
+          unsafe {
+            touch = *ev.data.touchPadMove();
+          }
+          println!("TouchPadMove event on #{}: {:?}", ev.trackedDeviceIndex, touch);
+        },
+        */
+        _ => ()
+      }
+    }
+
+    for (pad, old) in pads.iter_mut() {
+      if let Some(state) = vr.get_controller_state(*pad) {
+        if let Some(old_state) = *old {
+          if state.unPacketNum == old_state.unPacketNum {
+            continue;
+          }
+        }
+        *old = Some(state);
+        println!("state for {}: {:?}", *pad, state);
+      }
+    }
+
+    // handle window events
+    while let Some(ev) = window.poll_event() {
+      match ev {
+        piston_window::Input::Text(_) => break 'main,
+        _ => debug!("\t{:?}", ev)
+      }
+    }
+  }
+}

src/lib.rs

@@ -1,7 +1,7 @@
 #![feature(conservative_impl_trait)]
 
 #[macro_use] extern crate gfx;
-#[macro_use] extern crate log;
+extern crate log;
 extern crate nalgebra as na;
 extern crate num_traits;
 extern crate piston;

src/message.rs

@@ -0,0 +1,23 @@
+use std::time::SystemTime;
+
+struct Message {
+  text: String,
+  end_time: SystemTime,
+}
+
+impl Message {
+  pub fn new() -> Message {
+    Message {
+      text: String::new(),
+      end_time: SystemTime::now(),
+    }
+  }
+
+  pub fn display(&mut self, text: String) {
+    self.text = text;
+    self.end_time = SystemTime::now() + 5000;
+  }
+
+  pub fn render(&self) {
+  }
+}

src/vr.rs

@@ -159,7 +159,7 @@ pub fn create_eyebuffer<T, D>(factory: &mut gfx_device_gl::Factory,
                                         texture::AaMode::Single),
                       1, // levels
                       gfx::RENDER_TARGET, // bind
-                      gfx::memory::Usage::GpuOnly, // Usage
+                      gfx::memory::Usage::Data, // Usage
                       Some(<T::Channel as gfx::format::ChannelTyped>::get_channel_type()))?; // hint: format::ChannelType?
   let tgt = factory.view_texture_as_render_target(&tex, 0, None)?;
   let depth = factory.create_depth_stencil_view_only(size.width as texture::Size,