jrd/vrtue
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove bitrot, update and set versions of all deps, notably gfx & nalgebra

Browse Source
This commit is contained in:
Jared Burce
2018-08-14 15:25:44 -07:00
parent 493563b7cc
commit 7ac96862eb
9 changed files with 209 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
Cargo.toml
View File

@@ -1,7 +1,7 @@
[package]
name = "vrtue"
version = "0.1.0"
authors = ["Jared Roberts <jaredr@gmail.com>"]
authors = ["Jared Burce <jaredr@gmail.com>"]
[dependencies]
env_logger = "0.3"
@@ -9,17 +9,16 @@ itertools = ">=0.4"
log = "0.3"
memmap = "~0.2"
gl = "*"
gfx = "*"
gfx_device_gl = "*"
image = "*"
lzw = "*"
nalgebra = "*"
num-traits = "*"
openvr = { git = "https://github.com/rust-openvr/rust-openvr" }
openvr_sys = "*"
piston = "*"
piston_window = "*"
gl = "0.10"
gfx = "0.17"
gfx_device_gl = "0.15"
image = "0.19"
lzw = "0.10"
nalgebra = "0.16"
openvr = "0.5"
openvr_sys = "2"
piston = "0.37"
piston_window = "0.80"
[profile.release]
lto = true

33
src/bin/click.rs
View File

@@ -4,7 +4,6 @@ use vrtue::vr;
extern crate env_logger;
extern crate gfx;
#[macro_use] extern crate log;
extern crate openvr_sys;
extern crate piston_window;
use self::piston_window::{PistonWindow, Window, WindowSettings};
@@ -22,9 +21,9 @@ pub fn main() {
.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)
let left: vr::EyeBuffer<ColorFormat, DepthFormat> = vr::create_eyebuffer(&mut window.factory, render_size.0, render_size.1)
.expect("create left renderbuffer");
let right: vr::EyeBuffer<ColorFormat, DepthFormat> = vr::create_eyebuffer(&mut window.factory, render_size)
let right: vr::EyeBuffer<ColorFormat, DepthFormat> = vr::create_eyebuffer(&mut window.factory, render_size.0, render_size.1)
.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);
@@ -32,31 +31,31 @@ pub fn main() {
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 pads = ::std::collections::BTreeMap::<_, Option<vr::ControllerState>>::new();
'main: loop {
let _poses = vr.poses();
vr.submit(vr::Eye::Left, &left.tex);
vr.submit(vr::Eye::Right, &right.tex);
vr.submit(vr::Eye::Left, &left.tex).expect("submit left eye");
vr.submit(vr::Eye::Right, &right.tex).expect("submit right eye");
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::Press { dev_idx, button } => {
println!("Press event on #{}: {}", dev_idx, button);
},
vr::Event::Unpress { dev_idx, controller } => {
println!("Unpress event on #{}: {:?}", dev_idx, controller);
vr::Event::Unpress { dev_idx, button } => {
println!("Unpress event on #{}: {}", dev_idx, button);
},
vr::Event::Touch { dev_idx, controller } => {
if controller.button == openvr_sys::EVRButtonId_k_EButton_SteamVR_Touchpad as u32 {
vr::Event::Touch { dev_idx, button } => {
if button == vr::button_id::STEAM_VR_TOUCHPAD as u32 {
pads.insert(dev_idx, None);
}
println!("Touch event on #{}: {:?}", dev_idx, controller);
println!("Touch event on #{}: {}", dev_idx, button);
},
vr::Event::Untouch { dev_idx, controller } => {
if controller.button == openvr_sys::EVRButtonId_k_EButton_SteamVR_Touchpad as u32 {
vr::Event::Untouch { dev_idx, button } => {
if button == vr::button_id::STEAM_VR_TOUCHPAD as u32 {
pads.remove(&dev_idx);
}
println!("Untouch event on #{}: {:?}", dev_idx, controller);
println!("Untouch event on #{}: {}", dev_idx, button);
},
/*
t if t == openvr_sys::EVREventType::EVREventType_VREvent_TouchPadMove as u32 => {
@@ -74,7 +73,7 @@ pub fn main() {
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 {
if state.packet_num == old_state.packet_num {
continue;
}
}

8
src/bin/vrtue.rs
View File

@@ -8,7 +8,7 @@ extern crate gfx_device_gl;
extern crate piston;
extern crate piston_window;
use self::piston::input::{Button, Input, Key};
use self::piston::input::{Button, ButtonArgs, Input, Key};
use self::piston_window::{PistonWindow, Window, WindowSettings};
use std::env;
@@ -37,13 +37,13 @@ pub fn main() {
//while let Some(_) = window.next() {
loop {
scene.update(&mut vr, &mut window.encoder);
view.draw(&mut window, &mut vr, &scene);
view.draw(&mut window, &mut vr, &scene).expect("main draw");
// handle window events
while let Some(ev) = window.poll_event() {
match ev {
Input::Press(Button::Keyboard(Key::Space)) |
Input::Press(Button::Keyboard(Key::Escape)) => break 'main,
Input::Button(ButtonArgs { button: Button::Keyboard(Key::Space), .. }) |
Input::Button(ButtonArgs { button: Button::Keyboard(Key::Escape), .. }) => break 'main,
_ => debug!("\t{:?}", ev)
}

5
src/lib.rs
View File

@@ -1,9 +1,8 @@
#![feature(conservative_impl_trait)]
#![feature(iterator_flatten)]
#[macro_use] extern crate gfx;
#[macro_use] extern crate log;
#[allow(unused_imports)] #[macro_use] extern crate log;
extern crate nalgebra as na;
extern crate num_traits;
extern crate piston;
pub mod arena;

140
src/scenes/world.rs
View File

@@ -13,9 +13,8 @@ use std::time::SystemTime;
use gfx::{self, texture};
use gfx::traits::FactoryExt;
use na::{self, ToHomogeneous};
use num_traits::identities::One;
use piston::input::{Button, Input, Key};
use na;
use piston::input::{Button, ButtonArgs, ButtonState, Input, Key};
const PI: f32 = ::std::f32::consts::PI;
const TWO_PI_CIRC: f32 = 2.0 * PI / 256.0;
@@ -135,7 +134,7 @@ pub struct WorldScene<D: gfx::Device,
start_time: SystemTime,
treadmills: (f32, f32),
pads: BTreeMap<u32, (TrackMode, Option<vr::VRControllerState_t>)>,
pads: BTreeMap<u32, (TrackMode, Option<vr::ControllerState>)>,
_worldmap: model::World,
lat: u8,
@@ -156,7 +155,7 @@ impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
FRAGMENT_SHADER_SRC,
pipe::new())
.expect("create pipeline"),
camera: na::Matrix4::one(),
camera: na::Matrix4::identity(),
constants: Constants { anim: ANIMDATA,
r1: R1, r2: R2, r3: R3,
haze: 1.0/2.0f32.sqrt(), hazecolor: SKY_COLOR },
@@ -164,7 +163,7 @@ impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
constants_dirty: true,
locals: factory.create_constant_buffer(1),
atlas: tile::get_tiles::<_, _, view::ColorFormat>(device, factory, aux_command),
sampler: factory.create_sampler(texture::SamplerInfo::new(texture::FilterMethod::Jrd,
sampler: factory.create_sampler(texture::SamplerInfo::new(texture::FilterMethod::Trilinear, //::Jrd
texture::WrapMode::Tile)),
f: PhantomData,
@@ -217,60 +216,67 @@ impl<D: gfx::Device,
self.pads.remove(&dev_idx);
},
// treadmill / camera reset
Piston(Input::Press(Button::Keyboard(Key::Backspace))) => {
self.treadmills = (0.0, 0.0);
},
Piston(Input::Press(Button::Keyboard(Key::D0))) => {
self.camera = na::Matrix4::one();
},
Piston(Input::Button(ButtonArgs { state: ButtonState::Press,
button: Button::Keyboard(key),
.. })) => {
match key {
// treadmill / camera reset
Key::Backspace => {
self.treadmills = (0.0, 0.0);
},
Key::D0 => {
self.camera = na::Matrix4::identity();
},
// player movement
Piston(Input::Press(Button::Keyboard(Key::Up))) => {
self.lat = self.lat.wrapping_sub(1);
},
Piston(Input::Press(Button::Keyboard(Key::Down))) => {
self.lat = self.lat.wrapping_add(1);
},
Piston(Input::Press(Button::Keyboard(Key::Left))) => {
self.lng = self.lng.wrapping_sub(1);
},
Piston(Input::Press(Button::Keyboard(Key::Right))) => {
self.lng = self.lng.wrapping_add(1);
},
// player movement
Key::Up => {
self.lat = self.lat.wrapping_sub(1);
},
Key::Down => {
self.lat = self.lat.wrapping_add(1);
},
Key::Left => {
self.lng = self.lng.wrapping_sub(1);
},
Key::Right => {
self.lng = self.lng.wrapping_add(1);
},
// scale adjustment
Piston(Input::Press(Button::Keyboard(Key::Q))) => {
self.constants = Constants { r1: R1 / 2.0, r2: R2 / 2.0, r3: R3 / 2.0, ..self.constants };
self.constants_dirty = true;
},
Piston(Input::Press(Button::Keyboard(Key::D1))) => {
self.constants = Constants { r1: R1, r2: R2, r3: R3, ..self.constants };
self.constants_dirty = true;
},
Piston(Input::Press(Button::Keyboard(Key::D2))) => {
self.constants = Constants { r1: R1 * 2.0, r2: R2 * 2.0, r3: R3 * 2.0, ..self.constants };
self.constants_dirty = true;
},
Piston(Input::Press(Button::Keyboard(Key::D3))) => {
self.constants = Constants { r1: R1 * 4.0, r2: R2 * 4.0, r3: R3 * 4.0, ..self.constants };
self.constants_dirty = true;
},
Piston(Input::Press(Button::Keyboard(Key::D4))) => {
self.constants = Constants { r1: R1 * 16.0, r2: R2 * 16.0, r3: R3 * 16.0, ..self.constants };
self.constants_dirty = true;
},
// scale adjustment
Key::Q => {
self.constants = Constants { r1: R1 / 2.0, r2: R2 / 2.0, r3: R3 / 2.0, ..self.constants };
self.constants_dirty = true;
},
Key::D1 => {
self.constants = Constants { r1: R1, r2: R2, r3: R3, ..self.constants };
self.constants_dirty = true;
},
Key::D2 => {
self.constants = Constants { r1: R1 * 2.0, r2: R2 * 2.0, r3: R3 * 2.0, ..self.constants };
self.constants_dirty = true;
},
Key::D3 => {
self.constants = Constants { r1: R1 * 4.0, r2: R2 * 4.0, r3: R3 * 4.0, ..self.constants };
self.constants_dirty = true;
},
Key::D4 => {
self.constants = Constants { r1: R1 * 16.0, r2: R2 * 16.0, r3: R3 * 16.0, ..self.constants };
self.constants_dirty = true;
},
Piston(Input::Press(Button::Keyboard(Key::H))) => {
self.constants = Constants { haze: self.constants.haze * 2.0f32.sqrt().sqrt(), ..self.constants };
println!("haze: {}", self.constants.haze);
self.constants_dirty = true;
},
Piston(Input::Press(Button::Keyboard(Key::N))) => {
self.constants = Constants { haze: self.constants.haze / 2.0f32.sqrt().sqrt(), ..self.constants };
println!("haze: {}", self.constants.haze);
self.constants_dirty = true;
},
Key::H => {
self.constants = Constants { haze: self.constants.haze * 2.0f32.sqrt().sqrt(), ..self.constants };
println!("haze: {}", self.constants.haze);
self.constants_dirty = true;
},
Key::N => {
self.constants = Constants { haze: self.constants.haze / 2.0f32.sqrt().sqrt(), ..self.constants };
println!("haze: {}", self.constants.haze);
self.constants_dirty = true;
},
_ => ()
}
}
_ => ()
}
}
@@ -291,31 +297,31 @@ impl<D: gfx::Device,
TrackMode::Touch => {
const THRESHOLD: f32 = 0.005;
const SCALE: f32 = 32.0;
let xdiff = state.rAxis[0].x - old_state.rAxis[0].x;
let ydiff = state.rAxis[0].y - old_state.rAxis[0].y;
let xdiff = state.axis[0].x - old_state.axis[0].x;
let ydiff = state.axis[0].y - old_state.axis[0].y;
if xdiff.abs() > THRESHOLD { self.treadmills.0 += SCALE * xdiff; }
if ydiff.abs() > THRESHOLD { self.treadmills.1 += SCALE * ydiff; }
},
TrackMode::Press => {
let rot = na::Vector3::new(0.0, 0.0, 0.0);
let speed = R2 * 0.005;
if state.rAxis[0].x > 0.5 {
if state.axis[0].x > 0.5 {
self.camera = na::Similarity3::new(na::Vector3::new(-speed, 0.0, 0.0),
rot, 1.0).to_homogeneous() * self.camera;
} if state.rAxis[0].x < -0.5 {
} if state.axis[0].x < -0.5 {
self.camera = na::Similarity3::new(na::Vector3::new( speed, 0.0, 0.0),
rot, 1.0).to_homogeneous() * self.camera;
} if state.rAxis[0].y > 0.5 {
} if state.axis[0].y > 0.5 {
self.camera = na::Similarity3::new(na::Vector3::new( 0.0, -speed, 0.0),
rot, 1.0).to_homogeneous() * self.camera;
} if state.rAxis[0].y < -0.5 {
} if state.axis[0].y < -0.5 {
self.camera = na::Similarity3::new(na::Vector3::new( 0.0, speed, 0.0),
rot, 1.0).to_homogeneous() * self.camera;
}
},
}
if state.unPacketNum == old_state.unPacketNum {
if state.packet_num == old_state.packet_num {
continue;
}
}
@@ -359,9 +365,9 @@ impl<D: gfx::Device,
let (y, x) = (self.lat as f32 + 0.5, self.lng as f32 + 0.5); // center of tile
let eye = Self::toroid((x, y), r1, r2, r3);
let looktgt = Self::toroid((x, y - 1.0), r1, r2, r3); // look ahead = north
let normal = Self::toroid((x, y), 0.0, r2, r2) * na::Vector3::new(r2 / r3, 1.0, 1.0);
self.camera * na::Isometry3::look_at_rh(eye.as_point(),
looktgt.as_point(),
let normal = Self::toroid((x, y), 0.0, r2, r2).component_mul(&na::Vector3::new(r2 / r3, 1.0, 1.0));
self.camera * na::Isometry3::look_at_rh(&na::Point3::from_coordinates(eye),
&na::Point3::from_coordinates(looktgt),
&normal,
).to_homogeneous()
}

3
src/tile.rs
View File

@@ -34,6 +34,7 @@ pub fn get_tiles<D, F, T>(device: &mut D,
mipmap.dim as u16,
mipmap.len as u16,
texture::AaMode::Single),
texture::Mipmap::Provided,
&mipmap.slices())
.expect("create tile texture");
@@ -44,7 +45,7 @@ pub fn get_tiles<D, F, T>(device: &mut D,
let access = gfx::pso::AccessInfo::new();
let view = manager.ref_srv(tex.1.raw());
command.generate_mipmap(*view);
device.submit(command, &access);
device.submit(command, &access).expect("generate tile mipmaps");
}
tex.1
}

33
src/view.rs
View File

@@ -2,11 +2,12 @@ use vr::{self, AsMatrix4, VR};
extern crate gfx_device_gl;
extern crate piston_window;
extern crate openvr_sys;
use gfx;
use gfx::Device;
use gfx::traits::FactoryExt;
use na::{self, Inverse, ToHomogeneous};
use na;
use self::piston_window::{PistonWindow, Window};
pub type ColorFormat = gfx::format::Srgba8;
@@ -38,12 +39,12 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
if let &Some(ref vr) = vr {
let render_size = vr.recommended_render_target_size();
let render_size = vr::Size { width: render_size.width * 100 / 100,
height: render_size.height * 100 / 100 };
let render_size = (render_size.0 * 100 / 100,
render_size.1 * 100 / 100);
let left = vr::create_eyebuffer(&mut window.factory, render_size)
let left = vr::create_eyebuffer(&mut window.factory, render_size.0, render_size.1)
.expect("create left renderbuffer");
let right = vr::create_eyebuffer(&mut window.factory, render_size)
let right = vr::create_eyebuffer(&mut window.factory, render_size.0, render_size.1)
.expect("create right renderbuffer");
let trans = window.factory.create_constant_buffer(1);
@@ -67,13 +68,16 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
pub fn draw(&self,
window: &mut PistonWindow,
vr: &mut Option<vr::VR>,
scene: &::scene::Scene<gfx_device_gl::Device, gfx_device_gl::Factory>) {
scene: &::scene::Scene<gfx_device_gl::Device, gfx_device_gl::Factory>)
-> Result<(), vr::Error>
{
if let &mut Some(ref mut vr) = vr {
// Get the current sensor state
let poses = vr.poses();
let poses = vr.poses().expect("vr poses");
let mut hmd_mat = poses.poses[0].to_device.as_matrix4();
hmd_mat.inverse_mut();
let mut hmd_mat = poses[0].device_to_absolute_tracking().as_matrix4();
let inv_worked = hmd_mat.try_inverse_mut();
assert!(inv_worked, "hmd matrix invert");
for &(eye, buffers) in [(vr::Eye::Left, &self.left),
(vr::Eye::Right, &self.right)].into_iter() {
@@ -81,7 +85,7 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
let depth = &buffers.as_ref().expect("vr depth buffer").depth;
let proj_mat = vr.projection_matrix(eye, NEAR, FAR);
let eye_mat = vr.head_to_eye_transform(eye);
let mut eye_mat = vr.head_to_eye_transform(eye);
let scene_mat = scene.origin();
let viewmodel_mat = eye_mat * hmd_mat * scene_mat;
let trans = Trans { viewmodel: *viewmodel_mat.as_ref(),
@@ -99,11 +103,11 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
let head_mat = na::Similarity3::new(na::Vector3::new(0.0, -1.5, 0.0),
na::Vector3::new(0.0, 0.0, 0.0),
1.0).to_homogeneous();
let proj_mat = na::PerspectiveMatrix3::new(1.0, 90.0, NEAR, FAR).to_matrix();
let proj_mat = na::geometry::Perspective3::new(1.0, 90.0, NEAR, FAR);
let scene_mat = scene.origin();
let viewmodel_mat = head_mat * scene_mat;
let trans = Trans { viewmodel: *viewmodel_mat.as_ref(),
matrix: *(proj_mat * viewmodel_mat).as_ref() };
matrix: *(proj_mat.as_matrix() * viewmodel_mat).as_ref() };
window.encoder.update_constant_buffer(&self.trans, &trans);
}
// draw monitor window
@@ -117,10 +121,11 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
if let (&mut Some(ref mut vr),
&Some(ref left),
&Some(ref right)) = (vr, &self.left, &self.right) {
vr.submit(vr::Eye::Left, &left.tex);
vr.submit(vr::Eye::Right, &right.tex);
vr.submit(vr::Eye::Left, &left.tex)?;
vr.submit(vr::Eye::Right, &right.tex)?;
}
window.window.swap_buffers();
window.device.cleanup();
Ok(())
}
}

160
src/vr.rs
View File

@@ -1,60 +1,84 @@
extern crate gfx_device_gl;
extern crate openvr as vr;
extern crate openvr_sys;
pub use self::vr::Eye;
pub use self::vr::common::Size;
pub use self::openvr_sys::VRControllerState_t;
use std::fmt::Debug;
pub use self::vr::{compositor::texture::{ColorSpace, Handle, Texture},
ControllerState,
Eye,
system::Event as OvrEvent};
use gfx::{self, texture, Factory};
use gfx::memory::Typed;
use na::{self, Inverse};
use num_traits::identities::Zero;
use num_traits::identities::One;
use na;
use self::gfx_device_gl::Resources as GLResources;
use self::openvr_sys::{VREvent_Controller_t, VREvent_t};
pub struct VR {
system: vr::IVRSystem,
compositor: vr::IVRCompositor,
_context: vr::Context,
system: vr::System,
compositor: vr::Compositor,
origin: vr::TrackingUniverseOrigin,
gfx_handles: gfx::handle::Manager<GLResources>,
}
#[derive(Debug)]
pub enum Event {
Touch { dev_idx: u32, controller: VREvent_Controller_t },
Press { dev_idx: u32, controller: VREvent_Controller_t },
Unpress { dev_idx: u32, controller: VREvent_Controller_t },
Untouch { dev_idx: u32, controller: VREvent_Controller_t },
Other(VREvent_t),
Touch { dev_idx: u32, button: u32 },
Press { dev_idx: u32, button: u32 },
Unpress { dev_idx: u32, button: u32 },
Untouch { dev_idx: u32, button: u32 },
Other { dev_idx: u32, event: OvrEvent },
}
pub use self::vr::button_id;
#[derive(Debug)]
pub enum Error {
Init(Box<Debug>),
Poses(Box<Debug>),
Submit(Box<Debug>)
}
impl From<vr::InitError> for Error {
fn from(e: vr::InitError) -> Self {
Error::Init(Box::new(e))
}
}
impl VR {
pub fn new() -> Result<VR, vr::Error<openvr_sys::EVRInitError>> {
pub fn new() -> Result<VR, vr::InitError> {
let context = unsafe { vr::init(vr::ApplicationType::Scene)? };
Ok(VR {
system: vr::init()?,
compositor: vr::compositor()?,
system: context.system()?,
compositor: context.compositor()?,
_context: context,
origin: vr::TrackingUniverseOrigin::Standing,
gfx_handles: gfx::handle::Manager::new(),
})
}
pub fn poses(&mut self) -> vr::tracking::TrackedDevicePoses {
pub fn poses(&mut self) -> Result<vr::TrackedDevicePoses, Error> {
self.gfx_handles.clear();
self.compositor.wait_get_poses()
self.compositor.wait_get_poses().map(|p| p.render).map_err(|e| Error::Poses(Box::new(e)))
}
pub fn submit<T>(&mut self, eye: Eye, tex: &gfx::handle::Texture<GLResources, T>) {
pub fn submit<T>(&mut self, eye: Eye, tex: &gfx::handle::Texture<GLResources, T>)
-> Result<(), Error> {
let tex_id = match self.gfx_handles.ref_texture(tex.raw()) {
&gfx_device_gl::NewTexture::Surface(id) => id,
_ => panic!("Not a surface")
};
self.compositor.submit(eye,
tex_id as usize,
vr::common::TextureBounds::new((0.0, 1.0), (0.0, 1.0)));
unsafe {
self.compositor.submit(eye,
&Texture { handle: Handle::OpenGLRenderBuffer(tex_id as usize),
color_space: ColorSpace::Linear },
None,
None).map_err(|e| Error::Submit(Box::new(e)))
}
}
pub fn recommended_render_target_size(&self) -> Size {
pub fn recommended_render_target_size(&self) -> (u32, u32) {
self.system.recommended_render_target_size()
}
@@ -64,74 +88,52 @@ impl VR {
pub fn head_to_eye_transform(self: &Self, eye: Eye) -> na::Matrix4<f32> {
let mut mat = self.system.eye_to_head_transform(eye).as_matrix4();
assert!(mat.inverse_mut(), "inverse eye matrix");
let inv_worked = mat.try_inverse_mut();
assert!(inv_worked, "head_to_eye matrix invert");
mat
}
pub fn poll_next_event(&mut self) -> Option<Event> {
use self::openvr_sys::EVREventType as EvType;
unsafe {
let system = * { self.system.0 as *mut openvr_sys::VR_IVRSystem_FnTable };
let mut event: openvr_sys::VREvent_t = ::std::mem::zeroed();
let (event, _) = self.system.poll_next_event_with_pose(self.origin)?;
if system.PollNextEvent.unwrap()(&mut event,
::std::mem::size_of::<openvr_sys::VREvent_t>() as u32
) == 0 {
return None;
}
let dev_idx = event.trackedDeviceIndex;
Some(match ::std::mem::transmute(event.eventType) {
EvType::EVREventType_VREvent_ButtonTouch =>
Event::Touch { dev_idx: dev_idx as u32, controller: *event.data.controller() },
EvType::EVREventType_VREvent_ButtonPress =>
Event::Press { dev_idx: dev_idx as u32, controller: *event.data.controller() },
EvType::EVREventType_VREvent_ButtonUnpress =>
Event::Unpress { dev_idx: dev_idx as u32, controller: *event.data.controller() },
EvType::EVREventType_VREvent_ButtonUntouch =>
Event::Untouch { dev_idx: dev_idx as u32, controller: *event.data.controller() },
_ => Event::Other(event),
})
}
let dev_idx = event.tracked_device_index as u32;
Some(match event.event {
OvrEvent::ButtonTouch(controller) => Event::Touch { dev_idx: dev_idx,
button: controller.button },
OvrEvent::ButtonPress(controller) => Event::Press { dev_idx: dev_idx,
button: controller.button },
OvrEvent::ButtonUnpress(controller) => Event::Unpress { dev_idx: dev_idx,
button: controller.button },
OvrEvent::ButtonUntouch(controller) => Event::Untouch { dev_idx: dev_idx,
button: controller.button },
_ => Event::Other { dev_idx: dev_idx, event: event.event },
})
}
pub fn get_controller_state(&self, index: u32) -> Option<openvr_sys::VRControllerState_t> {
unsafe {
let system = * { self.system.0 as *const openvr_sys::VR_IVRSystem_FnTable };
let mut state: openvr_sys::VRControllerState_t = ::std::mem::zeroed();
match system.GetControllerState.unwrap()(
index,
&mut state,
) {
0 => None,
_ => Some(state)
}
}
pub fn get_controller_state(&self, index: u32) -> Option<ControllerState> {
self.system.controller_state(index)
}
}
impl Drop for VR {
fn drop(&mut self) {
vr::shutdown()
}
}
pub trait AsMatrix4<N> {
pub trait AsMatrix4<N: na::Real> {
fn as_matrix4(self) -> na::Matrix4<N>;
}
impl<N: Copy + Zero + One> AsMatrix4<N> for [[N; 4]; 3] {
impl<N: na::Real> AsMatrix4<N> for [[N; 4]; 3] {
#[inline]
fn as_matrix4(self) -> na::Matrix4<N> {
na::Matrix4::new(self[0][0], self[0][1], self[0][2], self[0][3],
self[1][0], self[1][1], self[1][2], self[1][3],
self[2][0], self[2][1], self[2][2], self[2][3],
N::zero(), N::zero(), N::zero(), N::one())
}
}
impl<N: Copy> AsMatrix4<N> for [[N; 4]; 4] {
impl<N: na::Real> AsMatrix4<N> for [[N; 4]; 4] {
#[inline]
fn as_matrix4(self) -> na::Matrix4<N> {
na::Matrix4::new(self[0][0], self[0][1], self[0][2], self[0][3],
self[1][0], self[1][1], self[1][2], self[1][3],
self[2][0], self[2][1], self[2][2], self[2][3],
@@ -139,6 +141,7 @@ impl<N: Copy> AsMatrix4<N> for [[N; 4]; 4] {
}
}
pub struct EyeBuffer<T, D>
where T: gfx::format::RenderFormat + gfx::format::TextureFormat,
D: gfx::format::DepthFormat + gfx::format::TextureFormat {
@@ -149,20 +152,21 @@ pub struct EyeBuffer<T, D>
}
pub fn create_eyebuffer<T, D>(factory: &mut gfx_device_gl::Factory,
size: Size)
width: u32,
height: u32)
-> Result<EyeBuffer<T, D>, gfx::CombinedError>
where T: gfx::format::RenderFormat + gfx::format::TextureFormat,
D: gfx::format::DepthFormat + gfx::format::TextureFormat {
let tex = factory
.create_texture(texture::Kind::D2(size.width as texture::Size,
size.height as texture::Size,
.create_texture(texture::Kind::D2(width as texture::Size,
height as texture::Size,
texture::AaMode::Single),
1, // levels
gfx::RENDER_TARGET, // bind
gfx::memory::Usage::GpuOnly, // Usage
gfx::memory::Bind::RENDER_TARGET, // bind
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,
size.height as texture::Size)?;
let depth = factory.create_depth_stencil_view_only(width as texture::Size,
height as texture::Size)?;
Ok(EyeBuffer { tex: tex, target: tgt, depth: depth })
}

4
src/world.rs
View File

@@ -1,7 +1,3 @@
extern crate itertools;
use self::itertools::Itertools;
use tile::Tile;
use transpose::TransposableIterator;