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

Compare commits

base: jrd:wip3
Branches Tags
jrd:master jrd:wip3 jrd:zzz jrd:wip2 jrd:mip2 jrd:wip jrd:cgmath
..
compare: jrd:wip2
Branches Tags
jrd:master jrd:wip3 jrd:zzz jrd:wip2 jrd:mip2 jrd:wip jrd:cgmath

1 Commits
wip3 ... wip2

Author SHA1 Message Date
Jared Roberts
5e0a514aa5 wip: walk along torus ridge 2016-10-18 11:14:39 -07:00
15 changed files with 147 additions and 529 deletions
Expand all files Collapse all files

7
Cargo.toml
View File

@@ -13,14 +13,9 @@ gl = "*"
gfx = "*" gfx = "*"
gfx_device_gl = "*" gfx_device_gl = "*"
image = "*" image = "*"
lzw = "*" nalgebra = "*"
nalgebra = "0.10"
num-traits = "*" num-traits = "*"
openvr = { git = "https://github.com/rust-openvr/rust-openvr" } openvr = { git = "https://github.com/rust-openvr/rust-openvr" }
openvr_sys = "*" openvr_sys = "*"
piston = "*" piston = "*"
piston_window = "*" piston_window = "*"
[profile.release]
lto = true
panic = "abort"

15
src/bin/init.rs
View File

@@ -1,15 +0,0 @@
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);
};
}

135
src/bin/poserelay.rs
View File

@@ -1,135 +0,0 @@
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)
}
}
}
}

10
src/bin/vrtue.rs
View File

@@ -15,9 +15,10 @@ use std::env;
pub fn main() { pub fn main() {
env_logger::init().expect("env logger"); env_logger::init().expect("env logger");
let mut vr = match env::var("NO_VR") { let mut vr = if env::var("NO_VR").is_ok() {
Ok(ref no_vr) if no_vr != "0" => None, None
_ => Some(vr::VR::new().expect("VR init")) } else {
Some(vr::VR::new().expect("VR init"))
}; };
let mut window: PistonWindow = let mut window: PistonWindow =
@@ -29,6 +30,7 @@ pub fn main() {
let mut aux_command = window.factory.create_command_buffer(); let mut aux_command = window.factory.create_command_buffer();
let mut scene = scenes::world::WorldScene::new(&mut window.device, let mut scene = scenes::world::WorldScene::new(&mut window.device,
&mut window.factory, &mut window.factory,
&mut window.encoder,
&mut aux_command); &mut aux_command);
let view = view::ViewRoot::<gfx_device_gl::Device, view::ColorFormat, view::DepthFormat> let view = view::ViewRoot::<gfx_device_gl::Device, view::ColorFormat, view::DepthFormat>
::create_view(&mut window, &mut vr); ::create_view(&mut window, &mut vr);
@@ -43,7 +45,7 @@ pub fn main() {
while let Some(ev) = window.poll_event() { while let Some(ev) = window.poll_event() {
match ev { match ev {
Input::Press(Button::Keyboard(Key::Space)) | Input::Press(Button::Keyboard(Key::Space)) |
Input::Press(Button::Keyboard(Key::Escape)) => break 'main, Input::Press(Button::Keyboard(Key::Escape)) => break'main,
_ => debug!("\t{:?}", ev) _ => debug!("\t{:?}", ev)
} }

195
src/ega.rs
View File

@@ -1,25 +1,19 @@
extern crate lzw; static EGA_PALETTE: [[u8; 4]; 16] = [[0x00, 0x00, 0x00, 0x00],
[0x00, 0x00, 0xAA, 0x00],
use std::cell::RefCell; [0x00, 0xAA, 0x00, 0x00],
[0x00, 0xAA, 0xAA, 0x00],
use self::lzw::BitReader; [0xAA, 0x00, 0x00, 0x00],
[0xAA, 0x00, 0xAA, 0x00],
static EGA_PALETTE: [[u8; 4]; 16] = [[0x00, 0x00, 0x00, 0xFF], [0xAA, 0x55, 0x00, 0x00],
[0x00, 0x00, 0xAA, 0xFF], [0xAA, 0xAA, 0xAA, 0x00],
[0x00, 0xAA, 0x00, 0xFF], [0x55, 0x55, 0x55, 0x00],
[0x00, 0xAA, 0xAA, 0xFF], [0x55, 0x55, 0xFF, 0x00],
[0xAA, 0x00, 0x00, 0xFF], [0x55, 0xFF, 0x55, 0x00],
[0xAA, 0x00, 0xAA, 0xFF], [0x55, 0xFF, 0xFF, 0x00],
[0xAA, 0x55, 0x00, 0xFF], [0xFF, 0x55, 0x55, 0x00],
[0xAA, 0xAA, 0xAA, 0xFF], [0xFF, 0x55, 0xFF, 0x00],
[0x55, 0x55, 0x55, 0xFF], [0xFF, 0xFF, 0x55, 0x00],
[0x55, 0x55, 0xFF, 0xFF], [0xFF, 0xFF, 0xFF, 0x00]];
[0x55, 0xFF, 0x55, 0xFF],
[0x55, 0xFF, 0xFF, 0xFF],
[0xFF, 0x55, 0x55, 0xFF],
[0xFF, 0x55, 0xFF, 0xFF],
[0xFF, 0xFF, 0x55, 0xFF],
[0xFF, 0xFF, 0xFF, 0xFF]];
pub enum Compression { pub enum Compression {
Uncompressed, Uncompressed,
@@ -104,14 +98,16 @@ pub fn decode<'a>(buf: &[u8], compression: Compression, tiling: Tiling)
let out: Vec<u8>; let out: Vec<u8>;
out = match compression { out = match compression {
Compression::Uncompressed => decode_uncompressed(buf), Compression::Uncompressed => buf.iter()
Compression::Rle => { .flat_map(|tile_byte| {
decode_uncompressed(&decode_rle(buf)) EGA_PALETTE[(tile_byte >> 4u8 & 0xF) as usize]
}, .into_iter()
Compression::Lzw => { .chain(EGA_PALETTE[(tile_byte & 0xF) as usize]
let mut decoder = U4Lzw::new(); .into_iter())
decode_uncompressed(&decoder.decode(buf)) })
}, .map(|x| *x)
.collect(),
_ => unimplemented!()
}; };
let dim = match tiling { let dim = match tiling {
Tiling::Tiled(tiledim) => tiledim as usize, Tiling::Tiled(tiledim) => tiledim as usize,
@@ -119,142 +115,3 @@ pub fn decode<'a>(buf: &[u8], compression: Compression, tiling: Tiling)
}; };
EgaPage { data: out, dim: dim} EgaPage { data: out, dim: dim}
} }
fn decode_uncompressed(buf: &[u8]) -> Vec<u8> {
buf.iter()
.flat_map(|tile_byte| {
EGA_PALETTE[(tile_byte >> 4u8 & 0xF) as usize]
.into_iter()
.chain(EGA_PALETTE[(tile_byte & 0xF) as usize]
.into_iter())
})
.map(|x| *x)
.collect()
}
fn decode_rle(bytes: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
let mut iter = bytes.iter();
while let Some(cmd) = iter.next() {
match cmd {
&0x02 => {
let len = *iter.next().expect("rle missing run length") as usize;
out.extend(::std::iter::repeat(*iter.next().expect("rle missing run value")).take(len));
},
val => out.push(*val),
}
}
out
}
struct U4Lzw {
table: Vec<RefCell<Vec<u8>>>,
load: u16,
}
const U4_CODE_SIZE: u8 = 12;
impl U4Lzw {
fn new() -> U4Lzw {
let mut out = U4Lzw {
table: vec![RefCell::new(Vec::new()); 1 << U4_CODE_SIZE],
load: 0
};
for (i, entry) in out.table.iter_mut().take(256).enumerate() {
entry.borrow_mut().push(i as u8)
}
out
}
fn reset(&mut self) {
for i in 256..(1 << U4_CODE_SIZE) {
self.table[i].borrow_mut().clear();
}
self.load = 0;
}
fn decode(&mut self, bytes: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
let mut iter = CodeIter::new(bytes);
let mut prev = iter.next().expect("empty lzw");
let mut ch = prev as u8;
out.push(ch);
for code in iter {
{
let mut new;
let mut seq = &*self.table[code as usize].borrow();
if seq.is_empty() {
new = self.table[prev as usize].borrow().clone();
new.push(ch);
seq = &new;
};
out.extend(seq.iter());
ch = seq[0];
}
let hash = self.hash(ch, prev);
{
let old = self.table[prev as usize].borrow();
let mut entry = self.table[hash].borrow_mut();
entry.extend(old.iter());
entry.push(ch);
}
prev = code;
self.load += 1;
if self.load > 0xccd { self.reset(); }
}
out
}
fn hash(&self, root: u8, code: u16) -> usize {
let hash = Self::hash_primary(root, code);
if self.table[hash].borrow().is_empty() { return hash; }
let mut hash = Self::hash_secondary(root, code);
while !self.table[hash].borrow().is_empty() {
hash = (hash + 509) & 0xfff
}
hash
}
fn hash_primary(root: u8, code: u16) -> usize {
((root as (u16) << 4) ^ code) as usize
}
fn hash_secondary(root: u8, code: u16) -> usize {
let base = (((root as (u16) << 1) + code) | 0x800) as u32;
let squared = base * base;
((squared & 0x0003ffc0) >> 6) as usize
}
}
struct CodeIter<'a> {
pos: usize,
bytes: &'a [u8],
reader: lzw::MsbReader,
}
impl<'a> CodeIter<'a> {
fn new(bytes: &[u8]) -> CodeIter {
CodeIter { pos: 0, bytes: bytes, reader: lzw::MsbReader::new() }
}
}
impl<'a> Iterator for CodeIter<'a> {
type Item = u16;
fn next(&mut self) -> Option<u16> {
match self.reader.read_bits(&self.bytes[self.pos..], U4_CODE_SIZE) {
lzw::Bits::Some(used, code) => {
self.pos += used;
Some(code)
},
lzw::Bits::None(used) => {
self.pos += used;
None
}
}
}
}

5
src/lib.rs
View File

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

23
src/message.rs
View File

@@ -1,23 +0,0 @@
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) {
}
}

10
src/scene.rs
View File

@@ -1,9 +1,11 @@
use gfx;
use na;
use piston;
use view; use view;
use vr; use vr;
extern crate gfx;
extern crate gfx_device_gl;
extern crate nalgebra as na;
extern crate piston_window;
pub trait Scene<D: gfx::Device, pub trait Scene<D: gfx::Device,
F: gfx::Factory<D::Resources>> { F: gfx::Factory<D::Resources>> {
fn event(&mut self, event: Event); fn event(&mut self, event: Event);
@@ -22,5 +24,5 @@ pub trait Scene<D: gfx::Device,
pub enum Event { pub enum Event {
Vr(vr::Event), Vr(vr::Event),
Piston(piston::input::Input), Piston(piston_window::Input),
} }

8
src/scenes/shader/tile_frag.glsl
View File

@@ -1,10 +1,9 @@
#version 150 #version 150
#define MILLIS_PER_TILE 3000u #define MILLIS_PER_TILE 4000u
in vec2 v_uv; in vec2 v_uv;
flat in uint v_tileidx; flat in uint v_tileidx;
in float v_fade;
out vec4 pixcolor; out vec4 pixcolor;
uniform sampler2DArray t_tiles; uniform sampler2DArray t_tiles;
uniform b_constants { uniform b_constants {
@@ -12,8 +11,6 @@ uniform b_constants {
float R1; float R1;
float R2; float R2;
float R3; float R3;
float haze;
vec4 hazecolor;
}; };
uniform b_locals { uniform b_locals {
uint millis; uint millis;
@@ -27,6 +24,5 @@ void main() {
anim_uv = vec2(v_uv.x, v_uv.y + float(millis % MILLIS_PER_TILE) / MILLIS_PER_TILE); anim_uv = vec2(v_uv.x, v_uv.y + float(millis % MILLIS_PER_TILE) / MILLIS_PER_TILE);
} }
vec4 texcolor = texture(t_tiles, vec3(anim_uv.x, 1.0 - anim_uv.y, v_tileidx)); pixcolor = texture(t_tiles, vec3(anim_uv.x, 1.0 - anim_uv.y, v_tileidx));
pixcolor = mix(texcolor, hazecolor, v_fade);
} }

12
src/scenes/shader/torus_vertex.glsl
View File

@@ -8,9 +8,7 @@ in vec2 a_uv;
in uint a_tileidx; in uint a_tileidx;
out vec2 v_uv; out vec2 v_uv;
flat out uint v_tileidx; flat out uint v_tileidx;
out float v_fade;
uniform b_trans { uniform b_trans {
mat4 u_viewmodel;
mat4 u_matrix; mat4 u_matrix;
}; };
uniform b_constants { uniform b_constants {
@@ -18,8 +16,6 @@ uniform b_constants {
float R1; float R1;
float R2; float R2;
float R3; float R3;
float haze;
vec4 hazecolor;
}; };
uniform b_locals { uniform b_locals {
uint millis; uint millis;
@@ -28,7 +24,7 @@ uniform b_locals {
}; };
vec3 toroid(vec2 src, float r1, float r2, float r3) { vec3 toroid(vec2 src, float r1, float r2, float r3) {
return vec3(r3 * sin(src.x), // use r3 instead of r2 for "deflated" torus return vec3(r3 * -1.0 * sin(src.x), // use r3 instead of r2 for "deflated" torus
(r1 + r2 * cos(src.x)) * cos(src.y), (r1 + r2 * cos(src.x)) * cos(src.y),
(r1 + r2 * cos(src.x)) * sin(src.y)); (r1 + r2 * cos(src.x)) * sin(src.y));
} }
@@ -42,9 +38,5 @@ void main() {
float height = R2 * 4 * TWO_PI_CIRC; float height = R2 * 4 * TWO_PI_CIRC;
vec3 normal = vec3(toroid(thetaphi, 0, height, height)) * vec3 normal = vec3(toroid(thetaphi, 0, height, height)) *
vec3(R2 / R3, 1.0, 1.0); vec3(R2 / R3, 1.0, 1.0);
vec4 model_pos = vec4(toroid(thetaphi, R1, R2, R3) + a_pos.z * normal, 1.0); gl_Position = u_matrix * vec4(toroid(thetaphi, R1, R2, R3) + a_pos.z * normal, 1.0);
gl_Position = u_matrix * model_pos;
vec4 view_pos = u_viewmodel * model_pos;
v_fade = min(1.0, length(view_pos.xyz) / R1 / 2 * haze);
} }

167
src/scenes/world.rs
View File

@@ -5,27 +5,29 @@ use vr;
use world as model; use world as model;
use world::HasMap; use world::HasMap;
extern crate memmap; extern crate gfx;
extern crate nalgebra as na;
extern crate num_traits;
extern crate openvr_sys;
extern crate piston;
extern crate piston_window;
use std::collections::BTreeMap; use std::collections::BTreeMap;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::time::SystemTime; use std::time::SystemTime;
use gfx::{self, texture}; use gfx::tex;
use gfx::traits::FactoryExt; use gfx::traits::FactoryExt;
use na::{self, ToHomogeneous}; use self::na::ToHomogeneous;
use num_traits::identities::One; use self::num_traits::identities::One;
use piston::input::{Button, Input, Key}; use self::piston::input::{Button, Input, Key};
const PI: f32 = ::std::f32::consts::PI;
const TWO_PI_CIRC: f32 = 2.0 * PI / 256.0;
const R1: f32 = 256.0; const R1: f32 = 256.0;
const R2: f32 = 64.0; const R2: f32 = 64.0;
const R3: f32 = 128.0; const R3: f32 = 128.0;
const PI: f32 = ::std::f32::consts::PI;
//const SKY_COLOR: [f32; 4] = [0.15, 0.15, 0.75, 1.0]; const TWO_PI: f32 = 2.0 * PI;
const SKY_COLOR: [f32; 4] = [0.005, 0.005, 0.01, 1.0]; const TWO_PI_CIRC: f32 = TWO_PI / 256.0;
gfx_defines! { gfx_defines! {
vertex Vertex { vertex Vertex {
@@ -39,8 +41,6 @@ gfx_defines! {
r1: f32 = "R1", r1: f32 = "R1",
r2: f32 = "R2", r2: f32 = "R2",
r3: f32 = "R3", r3: f32 = "R3",
haze: f32 = "haze",
hazecolor: [f32; 4] = "hazecolor",
} }
constant Locals { constant Locals {
@@ -81,24 +81,24 @@ fn get_model(world: &model::World) -> (Vec<Vertex>, Vec<u32>) {
let (rf, cf) = (r as f32, c as f32); let (rf, cf) = (r as f32, c as f32);
if alt == 0.0 { if alt == 0.0 {
verticies.extend_from_slice( verticies.extend_from_slice(
&[Vertex { pos: [ cf + 0., rf + 1., 0. ], uv: [0., 0.], tileidx: tileidx }, &[Vertex { pos: [ cf + 0., -rf - 1., 0. ], uv: [0., 0.], tileidx: tileidx },
Vertex { pos: [ cf + 1., rf + 1., 0. ], uv: [1., 0.], tileidx: tileidx }, Vertex { pos: [ cf + 1., -rf - 1., 0. ], uv: [1., 0.], tileidx: tileidx },
Vertex { pos: [ cf + 1., rf + 0., 0. ], uv: [1., 1.], tileidx: tileidx }, Vertex { pos: [ cf + 1., -rf - 0., 0. ], uv: [1., 1.], tileidx: tileidx },
Vertex { pos: [ cf + 0., rf + 0., 0. ], uv: [0., 1.], tileidx: tileidx },]); Vertex { pos: [ cf + 0., -rf - 0., 0. ], uv: [0., 1.], tileidx: tileidx },]);
indicies.extend_from_slice( indicies.extend_from_slice(
&[ v + 0, v + 1, v + 2, &[ v + 0, v + 1, v + 2,
v + 2, v + 3, v + 0 ]); v + 2, v + 3, v + 0 ]);
v += 4; v += 4;
} else { } else {
verticies.extend_from_slice( verticies.extend_from_slice(
&[Vertex { pos: [ cf + 0., rf + 1., 0. ], uv: [0., 0.], tileidx: tileidx }, &[Vertex { pos: [ cf + 0., -rf - 1., 0. ], uv: [0., 0.], tileidx: tileidx },
Vertex { pos: [ cf + 1., rf + 1., 0. ], uv: [1., 0.], tileidx: tileidx }, Vertex { pos: [ cf + 1., -rf - 1., 0. ], uv: [1., 0.], tileidx: tileidx },
Vertex { pos: [ cf + 1., rf + 0., 0. ], uv: [1., 1.], tileidx: tileidx }, Vertex { pos: [ cf + 1., -rf - 0., 0. ], uv: [1., 1.], tileidx: tileidx },
Vertex { pos: [ cf + 0., rf + 0., 0. ], uv: [0., 1.], tileidx: tileidx }, Vertex { pos: [ cf + 0., -rf - 0., 0. ], uv: [0., 1.], tileidx: tileidx },
Vertex { pos: [ cf + 0., rf, 0. ], uv: [0., 0.], tileidx: tileidx }, Vertex { pos: [ cf + 0., -rf, 0. ], uv: [0., 0.], tileidx: tileidx },
Vertex { pos: [ cf + 1., rf, 0. ], uv: [1., 0.], tileidx: tileidx }, Vertex { pos: [ cf + 1., -rf, 0. ], uv: [1., 0.], tileidx: tileidx },
Vertex { pos: [ cf + 1., rf, alt ], uv: [1., 1.], tileidx: tileidx }, Vertex { pos: [ cf + 1., -rf, alt ], uv: [1., 1.], tileidx: tileidx },
Vertex { pos: [ cf + 0., rf, alt ], uv: [0., 1.], tileidx: tileidx },]); Vertex { pos: [ cf + 0., -rf, alt ], uv: [0., 1.], tileidx: tileidx },]);
indicies.extend_from_slice( indicies.extend_from_slice(
&[ v + 0, v + 1, v + 2, &[ v + 0, v + 1, v + 2,
v + 2, v + 3, v + 0, v + 2, v + 3, v + 0,
@@ -121,9 +121,7 @@ pub struct WorldScene<D: gfx::Device,
F: gfx::Factory<D::Resources>> { F: gfx::Factory<D::Resources>> {
pso: gfx::PipelineState<D::Resources, pipe::Meta>, pso: gfx::PipelineState<D::Resources, pipe::Meta>,
camera: na::Matrix4<f32>, camera: na::Matrix4<f32>,
constants: Constants, constants: gfx::handle::Buffer<D::Resources, Constants>,
constants_buffer: gfx::handle::Buffer<D::Resources, Constants>,
constants_dirty: bool,
locals: gfx::handle::Buffer<D::Resources, Locals>, locals: gfx::handle::Buffer<D::Resources, Locals>,
atlas: gfx::handle::ShaderResourceView<D::Resources, atlas: gfx::handle::ShaderResourceView<D::Resources,
<view::ColorFormat as gfx::format::Formatted>::View>, <view::ColorFormat as gfx::format::Formatted>::View>,
@@ -135,37 +133,37 @@ pub struct WorldScene<D: gfx::Device,
start_time: SystemTime, start_time: SystemTime,
treadmills: (f32, f32), treadmills: (f32, f32),
pads: BTreeMap<u32, (TrackMode, Option<vr::VRControllerState_t>)>, pads: BTreeMap<u32, (TrackMode, Option<openvr_sys::VRControllerState_t>)>,
_worldmap: model::World, pos: (u8, u8),
lat: u8,
lng: u8,
} }
impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> { impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
pub fn new(device: &mut D, pub fn new(device: &mut D,
factory: &mut F, factory: &mut F,
encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>,
aux_command: &mut <D as gfx::Device>::CommandBuffer) -> WorldScene<D, F> { aux_command: &mut <D as gfx::Device>::CommandBuffer) -> WorldScene<D, F> {
let worldmap = get_data_model(); let (model, model_idx) = get_model(&get_data_model());
let (model, model_idx) = get_model(&worldmap);
let (vertex_buffer, slice) = let (vertex_buffer, slice) =
factory.create_vertex_buffer_with_slice(&model, &model_idx[..]); factory.create_vertex_buffer_with_slice(&model, &model_idx[..]);
let constants = factory.create_constant_buffer(1);
encoder.update_constant_buffer(&constants, &Constants { anim: ANIMDATA,
r1: R1,
r2: R2,
r3: R3});
WorldScene { WorldScene {
pso: factory.create_pipeline_simple(VERTEX_SHADER_SRC, pso: factory.create_pipeline_simple(VERTEX_SHADER_SRC,
FRAGMENT_SHADER_SRC, FRAGMENT_SHADER_SRC,
pipe::new()) pipe::new())
.expect("create pipeline"), .expect("create pipeline"),
camera: na::Matrix4::one(), camera: na::Matrix4::one(),
constants: Constants { anim: ANIMDATA, constants: constants,
r1: R1, r2: R2, r3: R3,
haze: 1.0/2.0f32.sqrt(), hazecolor: SKY_COLOR },
constants_buffer: factory.create_constant_buffer(1),
constants_dirty: true,
locals: factory.create_constant_buffer(1), locals: factory.create_constant_buffer(1),
atlas: tile::get_tiles::<_, _, view::ColorFormat>(device, factory, aux_command), atlas: tile::get_tiles::<_, _, view::ColorFormat>(device, factory, aux_command),
sampler: factory.create_sampler(texture::SamplerInfo::new(texture::FilterMethod::Jrd, sampler: factory.create_sampler(tex::SamplerInfo::new(tex::FilterMethod::Jrd,
texture::WrapMode::Tile)), tex::WrapMode::Tile)),
f: PhantomData, f: PhantomData,
vbuf: vertex_buffer, vbuf: vertex_buffer,
@@ -174,17 +172,15 @@ impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
treadmills: (0.0, 0.0), treadmills: (0.0, 0.0),
pads: BTreeMap::new(), pads: BTreeMap::new(),
_worldmap: worldmap, pos: (90, 144),
lat: 144,
lng: 90,
} }
} }
fn toroid((x, y): (f32, f32), r1: f32, r2: f32, r3: f32) -> na::Vector3<f32> fn toroid((x, y): (u8, u8), r1: f32, r2: f32, r3: f32) -> na::Vector3<f32>
{ {
let x: f32 = TWO_PI_CIRC * x as f32; let x: f32 = TWO_PI_CIRC * x as f32;
let y: f32 = TWO_PI_CIRC * y as f32; let y: f32 = TWO_PI_CIRC * y as f32;
na::Vector3::<f32>::new(r3 * x.sin(), // use r3 instead of r2 for "deflated" torus na::Vector3::<f32>::new(r3 * -1.0f32 * x.sin(), // use r3 instead of r2 for "deflated" torus
(r1 + r2 * x.cos()) * y.cos(), (r1 + r2 * x.cos()) * y.cos(),
(r1 + r2 * x.cos()) * y.sin()) (r1 + r2 * x.cos()) * y.sin())
} }
@@ -203,7 +199,6 @@ impl<D: gfx::Device,
use scene::Event::*; use scene::Event::*;
use vr::Event::*; use vr::Event::*;
match event { match event {
// treadmill / camera movement registration
Vr(Touch { dev_idx, .. }) => { Vr(Touch { dev_idx, .. }) => {
self.pads.insert(dev_idx, (TrackMode::Touch, None)); self.pads.insert(dev_idx, (TrackMode::Touch, None));
}, },
@@ -216,60 +211,21 @@ impl<D: gfx::Device,
Vr(Untouch { dev_idx, .. }) => { Vr(Untouch { dev_idx, .. }) => {
self.pads.remove(&dev_idx); 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();
},
// 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))) => { Piston(Input::Press(Button::Keyboard(Key::Left))) => {
self.lng = self.lng.wrapping_sub(1); self.pos = (self.pos.0.wrapping_sub(1), self.pos.1);
println!("x: {}, y: {}", self.pos.0, self.pos.1);
}, },
Piston(Input::Press(Button::Keyboard(Key::Right))) => { Piston(Input::Press(Button::Keyboard(Key::Right))) => {
self.lng = self.lng.wrapping_add(1); self.pos = (self.pos.0.wrapping_add(1), self.pos.1);
println!("x: {}, y: {}", self.pos.0, self.pos.1);
}, },
Piston(Input::Press(Button::Keyboard(Key::Up))) => {
// scale adjustment self.pos = (self.pos.0, self.pos.1.wrapping_sub(1));
Piston(Input::Press(Button::Keyboard(Key::Q))) => { println!("x: {}, y: {}", self.pos.0, self.pos.1);
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))) => { Piston(Input::Press(Button::Keyboard(Key::Down))) => {
self.constants = Constants { r1: R1, r2: R2, r3: R3, ..self.constants }; self.pos = (self.pos.0, self.pos.1.wrapping_add(1));
self.constants_dirty = true; println!("x: {}, y: {}", self.pos.0, self.pos.1);
},
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;
},
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;
}, },
_ => () _ => ()
} }
@@ -323,11 +279,6 @@ impl<D: gfx::Device,
} }
} }
if self.constants_dirty {
self.constants_dirty = false;
encoder.update_constant_buffer(&self.constants_buffer, &self.constants);
}
encoder.update_constant_buffer(&self.locals, &Locals { millis: millis, encoder.update_constant_buffer(&self.locals, &Locals { millis: millis,
treadmill_x: self.treadmills.0, treadmill_x: self.treadmills.0,
treadmill_y: self.treadmills.1 }); treadmill_y: self.treadmills.1 });
@@ -340,12 +291,10 @@ impl<D: gfx::Device,
target: &gfx::handle::RenderTargetView<D::Resources, view::ColorFormat>, target: &gfx::handle::RenderTargetView<D::Resources, view::ColorFormat>,
depth: &gfx::handle::DepthStencilView<D::Resources, view::DepthFormat>) { depth: &gfx::handle::DepthStencilView<D::Resources, view::DepthFormat>) {
encoder.clear(&target, SKY_COLOR);
encoder.clear_depth(&depth, 1.0);
let pipe = pipe::Data { let pipe = pipe::Data {
vbuf: self.vbuf.clone(), vbuf: self.vbuf.clone(),
trans: trans.clone(), trans: trans.clone(),
constants: self.constants_buffer.clone(), constants: self.constants.clone(),
locals: self.locals.clone(), locals: self.locals.clone(),
atlas: (self.atlas.clone(), self.sampler.clone()), atlas: (self.atlas.clone(), self.sampler.clone()),
pixcolor: target.clone(), pixcolor: target.clone(),
@@ -355,11 +304,10 @@ impl<D: gfx::Device,
} }
fn origin(&self) -> na::Matrix4<f32> { fn origin(&self) -> na::Matrix4<f32> {
let (r1, r2, r3) = (self.constants.r1, self.constants.r2, self.constants.r3); let (x, y) = (self.pos.0, self.pos.1);
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 eye = Self::toroid((x, y), r1, r2, r3); let looktgt = Self::toroid((x, y.wrapping_add(1)), 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);
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(), self.camera * na::Isometry3::look_at_rh(eye.as_point(),
looktgt.as_point(), looktgt.as_point(),
&normal, &normal,
@@ -367,6 +315,7 @@ impl<D: gfx::Device,
} }
} }
extern crate memmap;
fn get_data_model() -> model::World { fn get_data_model() -> model::World {
use self::memmap::{Mmap, Protection}; use self::memmap::{Mmap, Protection};
use std::mem::transmute; use std::mem::transmute;

23
src/tile.rs
View File

@@ -1,11 +1,13 @@
extern crate gfx;
use ega; use ega;
use ::std; use ::std;
use std::io::Read; use std::io::Read;
use std::path::Path; use std::path::Path;
use gfx::{self, texture, CommandBuffer}; use self::gfx::{CommandBuffer, Typed};
use gfx::memory::Typed; use self::gfx::tex;
const TILEDIM: u16 = 16; const TILEDIM: u16 = 16;
@@ -30,21 +32,18 @@ pub fn get_tiles<D, F, T>(device: &mut D,
let ega_page = ega::decode(&ega_bytes, ega::Compression::Uncompressed, ega::Tiling::Tiled(TILEDIM)); let ega_page = ega::decode(&ega_bytes, ega::Compression::Uncompressed, ega::Tiling::Tiled(TILEDIM));
let mipmap = ega_page.mipmap(2); let mipmap = ega_page.mipmap(2);
let tex = factory.create_texture_immutable_u8::<T>(texture::Kind::D2Array(mipmap.dim as u16, let tex = factory.create_texture_const_u8::<T>(tex::Kind::D2Array(mipmap.dim as u16,
mipmap.dim as u16, mipmap.dim as u16,
mipmap.len as u16, mipmap.len as u16,
texture::AaMode::Single), tex::AaMode::Single),
&mipmap.slices()) &mipmap.slices())
.expect("create tile texture"); .expect("create tile texture");
{ {
let mut manager = gfx::handle::Manager::<D::Resources>::new(); let mut manager = gfx::handle::Manager::<D::Resources>::new();
// XXX: Find out if Textures need to be/can be fenced like Buffers,
// Seems like I should mark tex.1 as being read/written, but it's not a Buffer?
let access = gfx::pso::AccessInfo::new();
let view = manager.ref_srv(tex.1.raw()); let view = manager.ref_srv(tex.1.raw());
command.generate_mipmap(*view); command.generate_mipmap(*view);
device.submit(command, &access); device.submit(command);
} }
tex.1 tex.1
} }

26
src/view.rs
View File

@@ -1,23 +1,25 @@
use vr::{self, AsMatrix4, VR}; use vr;
use vr::{AsMatrix4, VR};
extern crate gfx_device_gl; extern crate gfx_device_gl;
extern crate nalgebra as na;
extern crate num_traits;
extern crate piston_window; extern crate piston_window;
use gfx; use gfx;
use gfx::Device; use gfx::Device;
use gfx::traits::FactoryExt; use gfx::traits::FactoryExt;
use na::{self, Inverse, ToHomogeneous}; use self::na::{Inverse, ToHomogeneous};
use self::piston_window::{PistonWindow, Window}; use self::piston_window::{PistonWindow, Window};
pub type ColorFormat = gfx::format::Srgba8; pub type ColorFormat = gfx::format::Srgba8;
pub type DepthFormat = gfx::format::DepthStencil; pub type DepthFormat = gfx::format::DepthStencil;
const NEAR: f32 = 0.01; const NEAR: f32 = 0.01;
const FAR: f32 = 3072.0; const FAR: f32 = 1000.0;
gfx_constant_struct! { gfx_constant_struct! {
Trans { Trans {
viewmodel: [[f32; 4]; 4] = "u_viewmodel",
matrix: [[f32; 4]; 4] = "u_matrix", matrix: [[f32; 4]; 4] = "u_matrix",
} }
} }
@@ -38,8 +40,8 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
if let &Some(ref vr) = vr { if let &Some(ref vr) = vr {
let render_size = vr.recommended_render_target_size(); let render_size = vr.recommended_render_target_size();
let render_size = vr::Size { width: render_size.width * 100 / 100, let render_size = vr::Size { width: render_size.width * 220 / 100,
height: render_size.height * 100 / 100 }; height: render_size.height * 220 / 100 };
let left = vr::create_eyebuffer(&mut window.factory, render_size) let left = vr::create_eyebuffer(&mut window.factory, render_size)
.expect("create left renderbuffer"); .expect("create left renderbuffer");
@@ -79,13 +81,13 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
(vr::Eye::Right, &self.right)].into_iter() { (vr::Eye::Right, &self.right)].into_iter() {
let target = &buffers.as_ref().expect("vr color buffer").target; let target = &buffers.as_ref().expect("vr color buffer").target;
let depth = &buffers.as_ref().expect("vr depth buffer").depth; let depth = &buffers.as_ref().expect("vr depth buffer").depth;
window.encoder.clear(target, [0.005, 0.005, 0.01, 1.0]);
window.encoder.clear_depth(depth, 1.0);
let proj_mat = vr.projection_matrix(eye, NEAR, FAR); let proj_mat = vr.projection_matrix(eye, NEAR, FAR);
let eye_mat = vr.head_to_eye_transform(eye); let eye_mat = vr.head_to_eye_transform(eye);
let scene_mat = scene.origin(); let scene_mat = scene.origin();
let viewmodel_mat = eye_mat * hmd_mat * scene_mat; let trans = Trans { matrix: *(proj_mat * eye_mat * hmd_mat * scene_mat).as_ref() };
let trans = Trans { viewmodel: *viewmodel_mat.as_ref(),
matrix: *(proj_mat * viewmodel_mat).as_ref() };
window.encoder.update_constant_buffer(&self.trans, &trans); window.encoder.update_constant_buffer(&self.trans, &trans);
scene.render(&mut window.factory, scene.render(&mut window.factory,
@@ -101,12 +103,12 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
1.0).to_homogeneous(); 1.0).to_homogeneous();
let proj_mat = na::PerspectiveMatrix3::new(1.0, 90.0, NEAR, FAR).to_matrix(); let proj_mat = na::PerspectiveMatrix3::new(1.0, 90.0, NEAR, FAR).to_matrix();
let scene_mat = scene.origin(); let scene_mat = scene.origin();
let viewmodel_mat = head_mat * scene_mat; let trans = Trans { matrix: *(proj_mat * head_mat * scene_mat).as_ref() };
let trans = Trans { viewmodel: *viewmodel_mat.as_ref(),
matrix: *(proj_mat * viewmodel_mat).as_ref() };
window.encoder.update_constant_buffer(&self.trans, &trans); window.encoder.update_constant_buffer(&self.trans, &trans);
} }
// draw monitor window // draw monitor window
window.encoder.clear(&window.output_color, [0.005, 0.005, 0.01, 1.0]);
window.encoder.clear_depth(&window.output_stencil, 1.0);
scene.render(&mut window.factory, scene.render(&mut window.factory,
&mut window.encoder, &mut window.encoder,
&self.trans, &self.trans,

39
src/vr.rs
View File

@@ -1,18 +1,19 @@
extern crate gfx;
extern crate gfx_device_gl; extern crate gfx_device_gl;
extern crate nalgebra as na;
extern crate num_traits;
extern crate openvr as vr; extern crate openvr as vr;
extern crate openvr_sys; extern crate openvr_sys;
pub use self::vr::Eye; pub use self::vr::Eye;
pub use self::vr::common::Size; pub use self::vr::common::Size;
pub use self::openvr_sys::VRControllerState_t; pub use self::vr::tracking::{TrackedDeviceClass, TrackedDevicePoses};
use gfx::{self, texture, Factory};
use gfx::memory::Typed;
use na::{self, Inverse};
use num_traits::identities::Zero;
use num_traits::identities::One;
use self::gfx::{tex, Factory, Typed};
use self::gfx_device_gl::Resources as GLResources; use self::gfx_device_gl::Resources as GLResources;
use self::na::Inverse;
use self::num_traits::identities::Zero;
use self::num_traits::identities::One;
use self::openvr_sys::{VREvent_Controller_t, VREvent_t}; use self::openvr_sys::{VREvent_Controller_t, VREvent_t};
pub struct VR { pub struct VR {
@@ -33,8 +34,8 @@ pub enum Event {
impl VR { impl VR {
pub fn new() -> Result<VR, vr::Error<openvr_sys::EVRInitError>> { pub fn new() -> Result<VR, vr::Error<openvr_sys::EVRInitError>> {
Ok(VR { Ok(VR {
system: vr::init()?, system: try!(vr::init()),
compositor: vr::compositor()?, compositor: try!(vr::compositor()),
gfx_handles: gfx::handle::Manager::new(), gfx_handles: gfx::handle::Manager::new(),
}) })
} }
@@ -153,16 +154,14 @@ pub fn create_eyebuffer<T, D>(factory: &mut gfx_device_gl::Factory,
-> Result<EyeBuffer<T, D>, gfx::CombinedError> -> Result<EyeBuffer<T, D>, gfx::CombinedError>
where T: gfx::format::RenderFormat + gfx::format::TextureFormat, where T: gfx::format::RenderFormat + gfx::format::TextureFormat,
D: gfx::format::DepthFormat + gfx::format::TextureFormat { D: gfx::format::DepthFormat + gfx::format::TextureFormat {
let tex = factory let tex = try!(factory.create_texture(
.create_texture(texture::Kind::D2(size.width as texture::Size, tex::Kind::D2(size.width as tex::Size, size.height as tex::Size, tex::AaMode::Single),
size.height as texture::Size, 1, // levels
texture::AaMode::Single), gfx::RENDER_TARGET, // bind
1, // levels gfx::Usage::GpuOnly, // Usage
gfx::RENDER_TARGET, // bind Some(<T::Channel as gfx::format::ChannelTyped>::get_channel_type()))); // hint: format::ChannelType?
gfx::memory::Usage::Data, // Usage let tgt = try!(factory.view_texture_as_render_target(&tex, 0, None));
Some(<T::Channel as gfx::format::ChannelTyped>::get_channel_type()))?; // hint: format::ChannelType? let depth = try!(factory.create_depth_stencil_view_only(size.width as tex::Size,
let tgt = factory.view_texture_as_render_target(&tex, 0, None)?; size.height as tex::Size));
let depth = factory.create_depth_stencil_view_only(size.width as texture::Size,
size.height as texture::Size)?;
Ok(EyeBuffer { tex: tex, target: tgt, depth: depth }) Ok(EyeBuffer { tex: tex, target: tgt, depth: depth })
} }

1
src/world.rs
View File

@@ -1,3 +1,4 @@
extern crate core;
extern crate itertools; extern crate itertools;
use self::itertools::Itertools; use self::itertools::Itertools;