michael/pathfinder
michael
/
pathfinder
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Refactor the demo a bit

This commit is contained in:
Patrick Walton 2019-02-08 15:16:53 -08:00
parent dbf880d011
commit 725834285b
2 changed files with 223 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

158
demo/src/main.rs
View File

@ -27,9 +27,10 @@ use pathfinder_renderer::scene::Scene;
use pathfinder_renderer::z_buffer::ZBuffer; use pathfinder_renderer::z_buffer::ZBuffer;
use pathfinder_svg::SceneExt; use pathfinder_svg::SceneExt;
use rayon::ThreadPoolBuilder; use rayon::ThreadPoolBuilder;
use sdl2::{EventPump, Sdl, VideoSubsystem};
use sdl2::event::{Event, WindowEvent}; use sdl2::event::{Event, WindowEvent};
use sdl2::keyboard::Keycode; use sdl2::keyboard::Keycode;
use sdl2::video::GLProfile; use sdl2::video::{GLContext, GLProfile, Window};
use std::f32::consts::FRAC_PI_4; use std::f32::consts::FRAC_PI_4;
use std::panic; use std::panic;
use std::path::PathBuf; use std::path::PathBuf;
@ -62,6 +63,33 @@ static EFFECTS_PNG_NAME: &'static str = "demo-effects";
static OPEN_PNG_NAME: &'static str = "demo-open"; static OPEN_PNG_NAME: &'static str = "demo-open";
fn main() { fn main() {
DemoApp::new().run();
}
struct DemoApp {
window: Window,
#[allow(dead_code)]
sdl_context: Sdl,
#[allow(dead_code)]
sdl_video: VideoSubsystem,
sdl_event_pump: EventPump,
#[allow(dead_code)]
gl_context: GLContext,
scale_factor: f32,
camera_position: Point3DF32,
camera_velocity: Point3DF32,
camera_yaw: f32,
camera_pitch: f32,
ui: DemoUI,
scene_thread_proxy: SceneThreadProxy,
renderer: Renderer,
}
impl DemoApp {
fn new() -> DemoApp {
let options = Options::get(); let options = Options::get();
let sdl_context = sdl2::init().unwrap(); let sdl_context = sdl2::init().unwrap();
@ -79,38 +107,57 @@ fn main() {
.build() .build()
.unwrap(); .unwrap();
let _gl_context = window.gl_create_context().unwrap(); let gl_context = window.gl_create_context().unwrap();
gl::load_with(|name| sdl_video.gl_get_proc_address(name) as *const _); gl::load_with(|name| sdl_video.gl_get_proc_address(name) as *const _);
let mut sdl_event_pump = sdl_context.event_pump().unwrap(); let sdl_event_pump = sdl_context.event_pump().unwrap();
let mut exit = false;
let (window_width, _) = window.size(); let (window_width, _) = window.size();
let (drawable_width, drawable_height) = window.drawable_size(); let (drawable_width, drawable_height) = window.drawable_size();
let scale_factor = drawable_width / window_width; let drawable_size = Size2D::new(drawable_width, drawable_height);
let mut drawable_size = Size2D::new(drawable_width, drawable_height);
let mut renderer = Renderer::new(&drawable_size);
let mut camera_position = Point3DF32::new(500.0, 500.0, 3000.0, 1.0);
let mut camera_velocity = Point3DF32::new(0.0, 0.0, 0.0, 1.0);
let (mut camera_yaw, mut camera_pitch) = (0.0, 0.0);
let base_scene = load_scene(&options); let base_scene = load_scene(&options);
let scene_thread_proxy = SceneThreadProxy::new(base_scene, options.clone()); let scene_thread_proxy = SceneThreadProxy::new(base_scene, options.clone());
scene_thread_proxy.set_drawable_size(&drawable_size); scene_thread_proxy.set_drawable_size(&drawable_size);
let mut demo_ui = DemoUI::new(options); DemoApp {
window,
sdl_context,
sdl_video,
sdl_event_pump,
gl_context,
scale_factor: drawable_width as f32 / window_width as f32,
camera_position: Point3DF32::new(500.0, 500.0, 3000.0, 1.0),
camera_velocity: Point3DF32::new(0.0, 0.0, 0.0, 1.0),
camera_yaw: 0.0,
camera_pitch: 0.0,
ui: DemoUI::new(options),
scene_thread_proxy,
renderer: Renderer::new(&drawable_size),
}
}
fn run(&mut self) {
let mut exit = false;
let mut events = vec![]; let mut events = vec![];
let mut frame_counter = 0; let mut frame_counter = 0;
let mut mouselook_enabled = false; let mut mouselook_enabled = false;
let mut ui_event_handled_last_frame = false; let mut ui_event_handled_last_frame = false;
let (drawable_width, drawable_height) = self.window.drawable_size();
let mut drawable_size = Size2D::new(drawable_width, drawable_height);
while !exit { while !exit {
// Update the scene. // Update the scene.
let perspective = if demo_ui.threed_enabled { let perspective = if self.ui.threed_enabled {
let rotation = Transform3DF32::from_rotation(-camera_yaw, -camera_pitch, 0.0); let rotation = Transform3DF32::from_rotation(-self.camera_yaw,
camera_position = camera_position + rotation.transform_point(camera_velocity); -self.camera_pitch,
0.0);
self.camera_position = self.camera_position +
rotation.transform_point(self.camera_velocity);
let aspect = drawable_size.width as f32 / drawable_size.height as f32; let aspect = drawable_size.width as f32 / drawable_size.height as f32;
let mut transform = Transform3DF32::from_perspective(FRAC_PI_4, aspect, 0.025, 100.0); let mut transform = Transform3DF32::from_perspective(FRAC_PI_4, aspect, 0.025, 100.0);
@ -118,13 +165,13 @@ fn main() {
transform = transform.post_mul(&Transform3DF32::from_scale(1.0 / 800.0, transform = transform.post_mul(&Transform3DF32::from_scale(1.0 / 800.0,
1.0 / 800.0, 1.0 / 800.0,
1.0 / 800.0)); 1.0 / 800.0));
transform = transform.post_mul(&Transform3DF32::from_rotation(camera_yaw, transform = transform.post_mul(&Transform3DF32::from_rotation(self.camera_yaw,
camera_pitch, self.camera_pitch,
0.0)); 0.0));
transform = let translation = self.camera_position.scale(-1.0);
transform.post_mul(&Transform3DF32::from_translation(-camera_position.x(), transform = transform.post_mul(&Transform3DF32::from_translation(translation.x(),
-camera_position.y(), translation.y(),
-camera_position.z())); translation.z()));
Some(Perspective::new(&transform, &drawable_size)) Some(Perspective::new(&transform, &drawable_size))
} else { } else {
@ -133,10 +180,10 @@ fn main() {
let count = if frame_counter == 0 { 2 } else { 1 }; let count = if frame_counter == 0 { 2 } else { 1 };
for _ in 0..count { for _ in 0..count {
scene_thread_proxy.sender.send(MainToSceneMsg::Build(BuildOptions { self.scene_thread_proxy.sender.send(MainToSceneMsg::Build(BuildOptions {
perspective, perspective,
stem_darkening_font_size: if demo_ui.stem_darkening_effect_enabled { stem_darkening_font_size: if self.ui.stem_darkening_effect_enabled {
Some(APPROX_FONT_SIZE * scale_factor as f32) Some(APPROX_FONT_SIZE * self.scale_factor)
} else { } else {
None None
}, },
@ -148,54 +195,56 @@ fn main() {
let mut event_handled = false; let mut event_handled = false;
while !event_handled { while !event_handled {
let wait_for_event = let wait_for_event =
!camera_velocity.is_zero() && !self.camera_velocity.is_zero() &&
frame_counter >= 2 && frame_counter >= 2 &&
!ui_event_handled_last_frame; !ui_event_handled_last_frame;
if wait_for_event { if wait_for_event {
events.push(sdl_event_pump.wait_event()); events.push(self.sdl_event_pump.wait_event());
} }
for event in sdl_event_pump.poll_iter() { for event in self.sdl_event_pump.poll_iter() {
events.push(event); events.push(event);
} }
for event in events.drain(..) { for event in events.drain(..) {
match event { match event {
Event::Quit { .. } | Event::KeyDown { keycode: Some(Keycode::Escape), .. } => { Event::Quit { .. } |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
exit = true; exit = true;
} }
Event::Window { win_event: WindowEvent::SizeChanged(..), .. } => { Event::Window { win_event: WindowEvent::SizeChanged(..), .. } => {
let (drawable_width, drawable_height) = window.drawable_size(); let (drawable_width, drawable_height) = self.window.drawable_size();
drawable_size = Size2D::new(drawable_width as u32, drawable_height as u32); drawable_size = Size2D::new(drawable_width as u32,
scene_thread_proxy.set_drawable_size(&drawable_size); drawable_height as u32);
renderer.set_main_framebuffer_size(&drawable_size); self.scene_thread_proxy.set_drawable_size(&drawable_size);
self.renderer.set_main_framebuffer_size(&drawable_size);
} }
Event::MouseButtonDown { x, y, .. } => { Event::MouseButtonDown { x, y, .. } => {
let point = Point2DI32::new(x, y).scale(scale_factor as i32); let point = Point2DI32::new(x, y).scale(self.scale_factor as i32);
ui_event = UIEvent::MouseDown(point); ui_event = UIEvent::MouseDown(point);
} }
Event::MouseMotion { xrel, yrel, .. } if mouselook_enabled => { Event::MouseMotion { xrel, yrel, .. } if mouselook_enabled => {
camera_yaw += xrel as f32 * MOUSELOOK_ROTATION_SPEED; self.camera_yaw += xrel as f32 * MOUSELOOK_ROTATION_SPEED;
camera_pitch -= yrel as f32 * MOUSELOOK_ROTATION_SPEED; self.camera_pitch -= yrel as f32 * MOUSELOOK_ROTATION_SPEED;
} }
Event::KeyDown { keycode: Some(Keycode::W), .. } => { Event::KeyDown { keycode: Some(Keycode::W), .. } => {
camera_velocity.set_z(-CAMERA_VELOCITY) self.camera_velocity.set_z(-CAMERA_VELOCITY)
} }
Event::KeyDown { keycode: Some(Keycode::S), .. } => { Event::KeyDown { keycode: Some(Keycode::S), .. } => {
camera_velocity.set_z(CAMERA_VELOCITY) self.camera_velocity.set_z(CAMERA_VELOCITY)
} }
Event::KeyDown { keycode: Some(Keycode::A), .. } => { Event::KeyDown { keycode: Some(Keycode::A), .. } => {
camera_velocity.set_x(-CAMERA_VELOCITY) self.camera_velocity.set_x(-CAMERA_VELOCITY)
} }
Event::KeyDown { keycode: Some(Keycode::D), .. } => { Event::KeyDown { keycode: Some(Keycode::D), .. } => {
camera_velocity.set_x(CAMERA_VELOCITY) self.camera_velocity.set_x(CAMERA_VELOCITY)
} }
Event::KeyUp { keycode: Some(Keycode::W), .. } | Event::KeyUp { keycode: Some(Keycode::W), .. } |
Event::KeyUp { keycode: Some(Keycode::S), .. } => { Event::KeyUp { keycode: Some(Keycode::S), .. } => {
camera_velocity.set_z(0.0); self.camera_velocity.set_z(0.0);
} }
Event::KeyUp { keycode: Some(Keycode::A), .. } | Event::KeyUp { keycode: Some(Keycode::A), .. } |
Event::KeyUp { keycode: Some(Keycode::D), .. } => { Event::KeyUp { keycode: Some(Keycode::D), .. } => {
camera_velocity.set_x(0.0); self.camera_velocity.set_x(0.0);
} }
_ => continue, _ => continue,
} }
@ -213,7 +262,7 @@ fn main() {
let SceneToMainMsg::Render { let SceneToMainMsg::Render {
built_scene, built_scene,
tile_time tile_time
} = scene_thread_proxy.receiver.recv().unwrap(); } = self.scene_thread_proxy.receiver.recv().unwrap();
unsafe { unsafe {
gl::BindFramebuffer(gl::FRAMEBUFFER, 0); gl::BindFramebuffer(gl::FRAMEBUFFER, 0);
gl::ClearColor(BACKGROUND_COLOR.r as f32 / 255.0, gl::ClearColor(BACKGROUND_COLOR.r as f32 / 255.0,
@ -222,26 +271,26 @@ fn main() {
BACKGROUND_COLOR.a as f32 / 255.0); BACKGROUND_COLOR.a as f32 / 255.0);
gl::Clear(gl::COLOR_BUFFER_BIT); gl::Clear(gl::COLOR_BUFFER_BIT);
if demo_ui.gamma_correction_effect_enabled { if self.ui.gamma_correction_effect_enabled {
renderer.enable_gamma_correction(BACKGROUND_COLOR); self.renderer.enable_gamma_correction(BACKGROUND_COLOR);
} else { } else {
renderer.disable_gamma_correction(); self.renderer.disable_gamma_correction();
} }
if demo_ui.subpixel_aa_effect_enabled { if self.ui.subpixel_aa_effect_enabled {
renderer.enable_subpixel_aa(&DEFRINGING_KERNEL_CORE_GRAPHICS); self.renderer.enable_subpixel_aa(&DEFRINGING_KERNEL_CORE_GRAPHICS);
} else { } else {
renderer.disable_subpixel_aa(); self.renderer.disable_subpixel_aa();
} }
renderer.render_scene(&built_scene); self.renderer.render_scene(&built_scene);
let rendering_time = renderer.shift_timer_query(); let rendering_time = self.renderer.shift_timer_query();
renderer.debug_ui.add_sample(tile_time, rendering_time); self.renderer.debug_ui.add_sample(tile_time, rendering_time);
renderer.debug_ui.draw(); self.renderer.debug_ui.draw();
let had_ui_event = ui_event.is_none(); let had_ui_event = ui_event.is_none();
demo_ui.update(&mut renderer.debug_ui, &mut ui_event); self.ui.update(&mut self.renderer.debug_ui, &mut ui_event);
ui_event_handled_last_frame = had_ui_event && ui_event.is_none(); ui_event_handled_last_frame = had_ui_event && ui_event.is_none();
// If nothing handled the mouse-down event, toggle mouselook. // If nothing handled the mouse-down event, toggle mouselook.
@ -250,9 +299,10 @@ fn main() {
} }
} }
window.gl_swap_window(); self.window.gl_swap_window();
frame_counter += 1; frame_counter += 1;
} }
}
} }
struct SceneThreadProxy { struct SceneThreadProxy {

7
geometry/src/basic/point.rs
View File

@ -263,6 +263,13 @@ impl Point3DF32 {
self.0[3] self.0[3]
} }
#[inline]
pub fn scale(&self, x: f32) -> Point3DF32 {
let mut factors = F32x4::splat(x);
factors[3] = 1.0;
Point3DF32(self.0 * factors)
}
#[inline] #[inline]
pub fn set_x(&mut self, x: f32) { pub fn set_x(&mut self, x: f32) {
self.0[0] = x self.0[0] = x