408 lines
14 KiB
Rust
408 lines
14 KiB
Rust
use scene;
|
|
use tile;
|
|
use view;
|
|
use vr;
|
|
use world as model;
|
|
use world::HasMap;
|
|
|
|
extern crate memmap;
|
|
|
|
use std::collections::BTreeMap;
|
|
use std::marker::PhantomData;
|
|
use std::time::SystemTime;
|
|
|
|
use gfx::{self, texture};
|
|
use gfx::traits::FactoryExt;
|
|
use na;
|
|
use piston::input::{Button, ButtonArgs, ButtonState, Input, Key, Motion};
|
|
|
|
const PI: f32 = ::std::f32::consts::PI;
|
|
const TWO_PI_CIRC: f32 = 2.0 * PI / 256.0;
|
|
|
|
const R1: f32 = 256.0;
|
|
const R2: f32 = 64.0;
|
|
const R3: f32 = 128.0;
|
|
|
|
//const SKY_COLOR: [f32; 4] = [0.15, 0.15, 0.75, 1.0];
|
|
const SKY_COLOR: [f32; 4] = [0.005, 0.005, 0.01, 1.0];
|
|
|
|
gfx_defines! {
|
|
vertex Vertex {
|
|
pos: [f32; 3] = "a_pos",
|
|
uv: [f32; 2] = "a_uv",
|
|
tileidx: u32 = "a_tileidx",
|
|
}
|
|
|
|
constant Constants {
|
|
anim: [u32; 4] = "anim",
|
|
r1: f32 = "R1",
|
|
r2: f32 = "R2",
|
|
r3: f32 = "R3",
|
|
haze: f32 = "haze",
|
|
hazecolor: [f32; 4] = "hazecolor",
|
|
}
|
|
|
|
constant Locals {
|
|
millis: u32 = "millis",
|
|
treadmill_x: f32 = "treadmill_x",
|
|
treadmill_y: f32 = "treadmill_y",
|
|
}
|
|
|
|
pipeline pipe {
|
|
vbuf: gfx::VertexBuffer<Vertex> = (),
|
|
trans: gfx::ConstantBuffer<::view::Trans> = "b_trans",
|
|
constants: gfx::ConstantBuffer<Constants> = "b_constants",
|
|
locals: gfx::ConstantBuffer<Locals> = "b_locals",
|
|
atlas: gfx::TextureSampler<[f32; 4]> = "t_tiles",
|
|
pixcolor: gfx::RenderTarget<::view::ColorFormat> = "pixcolor",
|
|
depth: gfx::DepthTarget<::view::DepthFormat> = gfx::preset::depth::LESS_EQUAL_WRITE,
|
|
}
|
|
}
|
|
|
|
|
|
fn get_model(world: &model::World) -> (Vec<Vertex>, Vec<u32>) {
|
|
let mut verticies = Vec::new();
|
|
let mut indicies = Vec::new();
|
|
let mut v = 0;
|
|
|
|
for (r, row) in world.map().rows().enumerate() {
|
|
for (c, tile) in row.into_iter().enumerate() {
|
|
let tileidx = tile.val as u32;
|
|
let alt = match tileidx {
|
|
5 => 0.1,
|
|
6 => 0.8,
|
|
7 => 0.2,
|
|
8 => 1.5,
|
|
9 => 1.0,
|
|
10 | 11 | 12 => 1.0,
|
|
_ => 0.0,
|
|
};
|
|
let (rf, cf) = (r as f32, c as f32);
|
|
if alt == 0.0 {
|
|
verticies.extend_from_slice(
|
|
&[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 + 0., 0. ], uv: [1., 1.], tileidx: tileidx },
|
|
Vertex { pos: [ cf + 0., rf + 0., 0. ], uv: [0., 1.], tileidx: tileidx },]);
|
|
indicies.extend_from_slice(
|
|
&[ v + 0, v + 1, v + 2,
|
|
v + 2, v + 3, v + 0 ]);
|
|
v += 4;
|
|
} else {
|
|
verticies.extend_from_slice(
|
|
&[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 + 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. ], uv: [0., 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 + 0., rf, alt ], uv: [0., 1.], tileidx: tileidx },]);
|
|
indicies.extend_from_slice(
|
|
&[ v + 0, v + 1, v + 2,
|
|
v + 2, v + 3, v + 0,
|
|
v + 4, v + 5, v + 6,
|
|
v + 6, v + 7, v + 4 ]);
|
|
v += 8;
|
|
}
|
|
}
|
|
}
|
|
(verticies, indicies)
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
|
enum TrackMode {
|
|
Touch,
|
|
Press
|
|
}
|
|
|
|
pub struct WorldScene<D: gfx::Device,
|
|
F: gfx::Factory<D::Resources>> {
|
|
pso: gfx::PipelineState<D::Resources, pipe::Meta>,
|
|
camera: na::Matrix4<f32>,
|
|
constants: Constants,
|
|
constants_buffer: gfx::handle::Buffer<D::Resources, Constants>,
|
|
constants_dirty: bool,
|
|
locals: gfx::handle::Buffer<D::Resources, Locals>,
|
|
atlas: gfx::handle::ShaderResourceView<D::Resources,
|
|
<view::ColorFormat as gfx::format::Formatted>::View>,
|
|
sampler: gfx::handle::Sampler<D::Resources>,
|
|
f: PhantomData<F>,
|
|
|
|
vbuf: gfx::handle::Buffer<D::Resources, Vertex>,
|
|
slice: gfx::Slice<D::Resources>,
|
|
|
|
start_time: SystemTime,
|
|
treadmills: (f32, f32),
|
|
mouselook: na::Matrix4<f32>,
|
|
pads: BTreeMap<u32, (TrackMode, Option<vr::ControllerState>)>,
|
|
|
|
_worldmap: model::World,
|
|
lat: u8,
|
|
lng: u8,
|
|
}
|
|
|
|
impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
|
|
pub fn new(device: &mut D,
|
|
factory: &mut F,
|
|
aux_command: &mut <D as gfx::Device>::CommandBuffer) -> WorldScene<D, F> {
|
|
let worldmap = get_data_model();
|
|
let (model, model_idx) = get_model(&worldmap);
|
|
let (vertex_buffer, slice) =
|
|
factory.create_vertex_buffer_with_slice(&model, &model_idx[..]);
|
|
|
|
WorldScene {
|
|
pso: factory.create_pipeline_simple(VERTEX_SHADER_SRC,
|
|
FRAGMENT_SHADER_SRC,
|
|
pipe::new())
|
|
.expect("create pipeline"),
|
|
camera: na::Matrix4::identity(),
|
|
constants: Constants { anim: ANIMDATA,
|
|
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),
|
|
atlas: tile::get_tiles::<_, _, view::ColorFormat>(device, factory, aux_command),
|
|
sampler: factory.create_sampler(texture::SamplerInfo::new(texture::FilterMethod::Trilinear, //::Jrd
|
|
texture::WrapMode::Tile)),
|
|
f: PhantomData,
|
|
|
|
vbuf: vertex_buffer,
|
|
slice: slice,
|
|
start_time: SystemTime::now(),
|
|
treadmills: (0.0, 0.0),
|
|
mouselook: na::Matrix4::identity(),
|
|
pads: BTreeMap::new(),
|
|
|
|
_worldmap: worldmap,
|
|
lat: 144,
|
|
lng: 90,
|
|
}
|
|
}
|
|
|
|
fn toroid((x, y): (f32, f32), r1: f32, r2: f32, r3: f32) -> na::Vector3<f32>
|
|
{
|
|
let x: f32 = TWO_PI_CIRC * x 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
|
|
(r1 + r2 * x.cos()) * y.cos(),
|
|
(r1 + r2 * x.cos()) * y.sin())
|
|
}
|
|
}
|
|
|
|
const ANIMDATA: [u32; 4] =
|
|
[1 << 0 | 1 << 1 | 1 << 2,
|
|
0,
|
|
1 << (68 % 32) | 1 << (69 % 32) | 1 << (70 % 32) | 1 << (71 % 32) | 1 << (76 % 32),
|
|
0];
|
|
|
|
impl<D: gfx::Device,
|
|
F: gfx::Factory<D::Resources>> scene::Scene<D, F> for WorldScene<D, F> {
|
|
|
|
fn event(&mut self, event: scene::Event) {
|
|
use scene::Event::*;
|
|
use vr::Event::*;
|
|
match event {
|
|
// treadmill / camera movement registration
|
|
Vr(Touch { dev_idx, .. }) => {
|
|
self.pads.insert(dev_idx, (TrackMode::Touch, None));
|
|
},
|
|
Vr(Press { dev_idx, .. }) => {
|
|
self.pads.insert(dev_idx, (TrackMode::Press, None));
|
|
},
|
|
Vr(Unpress { dev_idx, .. }) => {
|
|
self.pads.insert(dev_idx, (TrackMode::Touch, None));
|
|
},
|
|
Vr(Untouch { dev_idx, .. }) => {
|
|
self.pads.remove(&dev_idx);
|
|
},
|
|
|
|
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
|
|
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
|
|
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;
|
|
},
|
|
|
|
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;
|
|
},
|
|
_ => ()
|
|
}
|
|
}
|
|
|
|
// mouselook
|
|
Piston(Input::Move(Motion::MouseCursor(x, y))) => {
|
|
self.mouselook = (
|
|
na::Rotation3::new(na::Vector3::<f32>::new(y as f32 / 300.0, 0.0, 0.0)) *
|
|
na::Rotation3::new(na::Vector3::<f32>::new(0.0, x as f32 / 300.0, 0.0))
|
|
).to_homogeneous();
|
|
},
|
|
_ => ()
|
|
}
|
|
}
|
|
|
|
fn update(&mut self,
|
|
vr: &mut Option<vr::VR>,
|
|
encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>) {
|
|
const NANOS_PER_MILLI: u32 = 1_000_000;
|
|
const MILLIS_PER_SEC: u64 = 1_000;
|
|
let elapsed = self.start_time.elapsed().expect("scene timer");
|
|
let millis = elapsed.subsec_nanos() / NANOS_PER_MILLI + (elapsed.as_secs() * MILLIS_PER_SEC) as u32;
|
|
|
|
for (pad, track) in self.pads.iter_mut() {
|
|
let mode = track.0;
|
|
if let Some(state) = vr.as_ref().and_then(|vr| vr.get_controller_state(*pad)) {
|
|
if let Some(old_state) = track.1 {
|
|
match mode {
|
|
TrackMode::Touch => {
|
|
const THRESHOLD: f32 = 0.005;
|
|
const SCALE: f32 = 32.0;
|
|
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.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.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.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.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.packet_num == old_state.packet_num {
|
|
continue;
|
|
}
|
|
}
|
|
*track = (mode, Some(state));
|
|
}
|
|
}
|
|
|
|
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,
|
|
treadmill_x: self.treadmills.0,
|
|
treadmill_y: self.treadmills.1 });
|
|
}
|
|
|
|
fn render(&self,
|
|
_factory: &mut F,
|
|
encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>,
|
|
trans: &gfx::handle::Buffer<D::Resources, view::Trans>,
|
|
target: &gfx::handle::RenderTargetView<D::Resources, view::ColorFormat>,
|
|
depth: &gfx::handle::DepthStencilView<D::Resources, view::DepthFormat>) {
|
|
|
|
encoder.clear(&target, SKY_COLOR);
|
|
encoder.clear_depth(&depth, 1.0);
|
|
let pipe = pipe::Data {
|
|
vbuf: self.vbuf.clone(),
|
|
trans: trans.clone(),
|
|
constants: self.constants_buffer.clone(),
|
|
locals: self.locals.clone(),
|
|
atlas: (self.atlas.clone(), self.sampler.clone()),
|
|
pixcolor: target.clone(),
|
|
depth: depth.clone(),
|
|
};
|
|
encoder.draw(&self.slice, &self.pso, &pipe);
|
|
}
|
|
|
|
fn origin(&self) -> na::Matrix4<f32> {
|
|
let (r1, r2, r3) = (self.constants.r1, self.constants.r2, self.constants.r3);
|
|
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).component_mul(&na::Vector3::new(r2 / r3, 1.0, 1.0));
|
|
self.camera * na::Isometry3::look_at_rh(&na::Point3::from(eye),
|
|
&na::Point3::from(looktgt),
|
|
&normal,
|
|
).to_homogeneous()
|
|
}
|
|
|
|
fn mouselook(&self) -> na::Matrix4<f32> {
|
|
self.mouselook
|
|
}
|
|
}
|
|
|
|
fn get_data_model() -> model::World {
|
|
use self::memmap::{Mmap, Protection};
|
|
use std::mem::transmute;
|
|
|
|
fn mmap_to_rows<'a, M: model::HasMap>(mmap: &memmap::Mmap) -> &'a M
|
|
where M: Copy + 'a
|
|
{
|
|
assert_eq!(::std::mem::size_of::<M>(), mmap.len());
|
|
unsafe { transmute::<*const u8, &M>(mmap.ptr()) }
|
|
}
|
|
|
|
let filename = "data/WORLD.MAP";
|
|
let file_mmap = Mmap::open_path(filename, Protection::Read).unwrap();
|
|
mmap_to_rows::<model::World>(&file_mmap).clone()
|
|
}
|
|
|
|
const VERTEX_SHADER_SRC: &'static [u8] = include_bytes!("shader/torus_vertex.glsl");
|
|
const FRAGMENT_SHADER_SRC: &'static [u8] = include_bytes!("shader/tile_frag.glsl");
|