Refactor the demo a bit

demo/src/main.rs

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

geometry/src/basic/point.rs

@@ -263,6 +263,13 @@ impl Point3DF32 {
         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]
     pub fn set_x(&mut self, x: f32) {
         self.0[0] = x