Update examples

examples/canvas_glutin_minimal/src/main.rs

@@ -24,7 +24,7 @@ use pathfinder_resources::embedded::EmbeddedResourceLoader;
 use pathfinder_renderer::concurrent::rayon::RayonExecutor;
 use pathfinder_renderer::concurrent::scene_proxy::SceneProxy;
 use pathfinder_renderer::gpu::renderer::Renderer;
-use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererOptions};
+use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererMode, RendererOptions};
 use pathfinder_renderer::options::BuildOptions;
 
 fn main() {
@@ -48,13 +48,14 @@ fn main() {
     gl::load_with(|name| gl_context.get_proc_address(name) as *const _);
 
     // Create a Pathfinder renderer.
-    let mut renderer = Renderer::new(GLDevice::new(GLVersion::GL3, 0),
+    let device = GLDevice::new(GLVersion::GL3, 0);
-                                     &EmbeddedResourceLoader,
+    let mode = RendererMode::default_for_device(&device);
-                                     DestFramebuffer::full_window(window_size),
+    let options = RendererOptions {
-                                     RendererOptions {
+        background_color: Some(ColorF::white()),
-                                         background_color: Some(ColorF::white()),
+        dest: DestFramebuffer::full_window(window_size),
-                                         ..RendererOptions::default()
+        ..RendererOptions::default()
-                                     });
+    };
+    let mut renderer = Renderer::new(device, &EmbeddedResourceLoader, mode, options);
 
     // Make a canvas. We're going to draw a house.
     let font_context = CanvasFontContext::from_system_source();
@@ -78,7 +79,9 @@ fn main() {
     canvas.stroke_path(path);
 
     // Render the canvas to screen.
-    let scene = SceneProxy::from_scene(canvas.into_canvas().into_scene(), RayonExecutor);
+    let mut scene = SceneProxy::from_scene(canvas.into_canvas().into_scene(),
+                                           renderer.mode().level,
+                                           RayonExecutor);
     scene.build_and_render(&mut renderer, BuildOptions::default());
     gl_context.swap_buffers().unwrap();
 

examples/canvas_metal_minimal/src/main.rs

@@ -10,14 +10,14 @@
 
 use foreign_types::ForeignTypeRef;
 use metal::{CAMetalLayer, CoreAnimationLayerRef};
-use pathfinder_canvas::{CanvasFontContext, CanvasRenderingContext2D, Path2D};
+use pathfinder_canvas::{Canvas, CanvasFontContext, Path2D};
 use pathfinder_color::ColorF;
-use pathfinder_geometry::vector::{Vector2F, Vector2I, vec2f, vec2i};
+use pathfinder_geometry::vector::{vec2f, vec2i};
 use pathfinder_geometry::rect::RectF;
 use pathfinder_metal::MetalDevice;
 use pathfinder_renderer::concurrent::rayon::RayonExecutor;
 use pathfinder_renderer::concurrent::scene_proxy::SceneProxy;
-use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererOptions};
+use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererMode, RendererOptions};
 use pathfinder_renderer::gpu::renderer::Renderer;
 use pathfinder_renderer::options::BuildOptions;
 use pathfinder_resources::embedded::EmbeddedResourceLoader;
@@ -46,14 +46,18 @@ fn main() {
     };
 
     // Create a Pathfinder renderer.
-    let mut renderer = Renderer::new(MetalDevice::new(metal_layer),
+    let device = MetalDevice::new(metal_layer);
-                                     &EmbeddedResourceLoader,
+    let mode = RendererMode::default_for_device(&device);
-                                     DestFramebuffer::full_window(window_size),
+    let options = RendererOptions {
-                                     RendererOptions { background_color: Some(ColorF::white()) });
+        dest: DestFramebuffer::full_window(window_size),
+        background_color: Some(ColorF::white()),
+        ..RendererOptions::default()
+    };
+    let mut renderer = Renderer::new(device, &EmbeddedResourceLoader, mode, options);
 
     // Make a canvas. We're going to draw a house.
-    let mut canvas = CanvasRenderingContext2D::new(CanvasFontContext::from_system_source(),
+    let canvas = Canvas::new(window_size.to_f32());
-                                                   window_size.to_f32());
+    let mut canvas = canvas.get_context_2d(CanvasFontContext::from_system_source());
 
     // Set line width.
     canvas.set_line_width(10.0);
@@ -73,9 +77,11 @@ fn main() {
     canvas.stroke_path(path);
 
     // Render the canvas to screen.
-    let scene = SceneProxy::from_scene(canvas.into_scene(), RayonExecutor);
+    let mut scene = SceneProxy::from_scene(canvas.into_canvas().into_scene(),
+                                           renderer.mode().level,
+                                           RayonExecutor);
     scene.build_and_render(&mut renderer, BuildOptions::default());
-    renderer.device.present_drawable();
+    renderer.device().present_drawable();
 
     // Wait for a keypress.
     let mut event_pump = sdl_context.event_pump().unwrap();

examples/canvas_minimal/src/main.rs

@@ -16,7 +16,7 @@ use pathfinder_geometry::vector::{vec2f, vec2i};
 use pathfinder_gl::{GLDevice, GLVersion};
 use pathfinder_renderer::concurrent::rayon::RayonExecutor;
 use pathfinder_renderer::concurrent::scene_proxy::SceneProxy;
-use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererOptions};
+use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererMode, RendererOptions};
 use pathfinder_renderer::gpu::renderer::Renderer;
 use pathfinder_renderer::options::BuildOptions;
 use pathfinder_resources::embedded::EmbeddedResourceLoader;
@@ -72,13 +72,14 @@ fn main() {
     let pathfinder_device = GLDevice::new(GLVersion::GL3, default_framebuffer);
 
     // Create a Pathfinder renderer.
-    let mut renderer = Renderer::new(pathfinder_device,
+    let mode = RendererMode::default_for_device(&pathfinder_device);
-                                     &EmbeddedResourceLoader::new(),
+    let options = RendererOptions {
-                                     DestFramebuffer::full_window(framebuffer_size),
+        dest: DestFramebuffer::full_window(framebuffer_size),
-                                     RendererOptions {
+        background_color: Some(ColorF::white()),
-                                         background_color: Some(ColorF::white()),
+        ..RendererOptions::default()
-                                         ..RendererOptions::default()
+    };
-                                     });
+    let resource_loader = EmbeddedResourceLoader::new();
+    let mut renderer = Renderer::new(pathfinder_device, &resource_loader, mode, options);
 
     // Make a canvas. We're going to draw a house.
     let font_context = CanvasFontContext::from_system_source();
@@ -102,7 +103,9 @@ fn main() {
     canvas.stroke_path(path);
 
     // Render the canvas to screen.
-    let scene = SceneProxy::from_scene(canvas.into_canvas().into_scene(), RayonExecutor);
+    let mut scene = SceneProxy::from_scene(canvas.into_canvas().into_scene(),
+                                           renderer.mode().level,
+                                           RayonExecutor);
     scene.build_and_render(&mut renderer, BuildOptions::default());
 
     // Present the surface.

examples/canvas_moire/src/main.rs

@@ -15,7 +15,7 @@ use pathfinder_geometry::vector::{Vector2F, Vector2I, vec2f, vec2i};
 use pathfinder_gl::{GLDevice, GLVersion};
 use pathfinder_renderer::concurrent::rayon::RayonExecutor;
 use pathfinder_renderer::concurrent::scene_proxy::SceneProxy;
-use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererOptions};
+use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererMode, RendererOptions};
 use pathfinder_renderer::gpu::renderer::Renderer;
 use pathfinder_renderer::options::BuildOptions;
 use pathfinder_resources::embedded::EmbeddedResourceLoader;
@@ -85,13 +85,13 @@ fn main() {
     let pathfinder_device = GLDevice::new(GLVersion::GL3, default_framebuffer);
 
     // Create our renderers.
-    let renderer = Renderer::new(pathfinder_device,
+    let mode = RendererMode::default_for_device(&pathfinder_device);
-                                 &EmbeddedResourceLoader,
+    let options = RendererOptions {
-                                 DestFramebuffer::full_window(framebuffer_size),
+        background_color: Some(ColorF::white()),
-                                 RendererOptions {
+        dest: DestFramebuffer::full_window(framebuffer_size),
-                                     background_color: Some(ColorF::white()),
+        ..RendererOptions::default()
-                                     ..RendererOptions::default()
+    };
-                                 });
+    let renderer = Renderer::new(pathfinder_device, &EmbeddedResourceLoader, mode, options);
     let window_size = vec2i(window_size.width, window_size.height);
     let mut moire_renderer = MoireRenderer::new(renderer, window_size, framebuffer_size);
 
@@ -129,10 +129,11 @@ struct MoireRenderer {
 impl MoireRenderer {
     fn new(renderer: Renderer<GLDevice>, window_size: Vector2I, drawable_size: Vector2I)
            -> MoireRenderer {
+        let level = renderer.mode().level;
         MoireRenderer {
             renderer,
             font_context: CanvasFontContext::from_system_source(),
-            scene: SceneProxy::new(RayonExecutor),
+            scene: SceneProxy::new(level, RayonExecutor),
             frame: 0,
             window_size,
             drawable_size,
@@ -155,10 +156,7 @@ impl MoireRenderer {
         let inner_center = window_center + vec2f(1.0, sin_time) * (cos_time * INNER_RADIUS);
 
         // Clear to background color.
-        self.renderer.set_options(RendererOptions {
+        self.renderer.options_mut().background_color = Some(background_color);
-            background_color: Some(background_color),
-            ..RendererOptions::default()
-        });
 
         // Make a canvas.
         let mut canvas =    

examples/canvas_nanovg/src/main.rs

@@ -1517,13 +1517,14 @@ fn main() {
     let pathfinder_device = GLDevice::new(GLVersion::GL3, default_framebuffer);
 
     // Create a Pathfinder renderer.
+    let renderer_options = RendererOptions {
+        background_color: Some(rgbf(0.3, 0.3, 0.32)),
+        ..RendererOptions::default_for_device(&pathfinder_device)
+    };
     let mut renderer = Renderer::new(pathfinder_device,
                                      &resources,
                                      DestFramebuffer::full_window(framebuffer_size),
-                                     RendererOptions {
+                                     renderer_options);
-                                         background_color: Some(rgbf(0.3, 0.3, 0.32)),
-                                         ..RendererOptions::default()
-                                     });
 
     // Initialize font state.
     let font_source = Arc::new(MemSource::from_fonts(font_data.into_iter()).unwrap());
@@ -1566,7 +1567,9 @@ fn main() {
 
         // Render the canvas to screen.
         let canvas = context.into_canvas();
-        let scene = SceneProxy::from_scene(canvas.into_scene(), RayonExecutor);
+        let mut scene = SceneProxy::from_scene(canvas.into_scene(),
+                                               renderer.level(),
+                                               RayonExecutor);
         scene.build_and_render(&mut renderer, BuildOptions::default());
 
         // Present the rendered canvas via `surfman`.
@@ -1575,9 +1578,9 @@ fn main() {
         device.bind_surface_to_context(&mut gl_context, surface).unwrap();
 
         // Add stats to performance graphs.
-        if let Some(gpu_time) = renderer.shift_rendering_time() {
+        if let Some(gpu_time) = renderer.last_rendering_time() {
-            let cpu_build_time = renderer.stats.cpu_build_time.as_secs_f32();
+            let cpu_build_time = renderer.stats().cpu_build_time.as_secs_f32();
-            let gpu_time = gpu_time.gpu_time.as_secs_f32();
+            let gpu_time = gpu_time.total_time().as_secs_f32();
             fps_graph.push(cpu_frame_elapsed_time + cpu_build_time.max(gpu_time));
             cpu_graph.push(cpu_frame_elapsed_time + cpu_build_time);
             gpu_graph.push(gpu_time);

examples/canvas_text/src/main.rs

@@ -15,11 +15,11 @@ use pathfinder_geometry::vector::{vec2f, vec2i};
 use pathfinder_gl::{GLDevice, GLVersion};
 use pathfinder_renderer::concurrent::rayon::RayonExecutor;
 use pathfinder_renderer::concurrent::scene_proxy::SceneProxy;
-use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererOptions};
+use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererMode, RendererOptions};
 use pathfinder_renderer::gpu::renderer::Renderer;
 use pathfinder_renderer::options::BuildOptions;
 use pathfinder_resources::ResourceLoader;
-use pathfinder_resources::embedded::EmbeddedResourceLoader;
+use pathfinder_resources::fs::FilesystemResourceLoader;
 use sdl2::event::Event;
 use sdl2::keyboard::Keycode;
 use sdl2::video::GLProfile;
@@ -49,14 +49,15 @@ fn main() {
     window.gl_make_current(&gl_context).unwrap();
 
     // Create a Pathfinder renderer.
-    let resource_loader = EmbeddedResourceLoader;
+    let resource_loader = FilesystemResourceLoader::locate();
-    let mut renderer = Renderer::new(GLDevice::new(GLVersion::GL3, 0),
+    let device = GLDevice::new(GLVersion::GL3, 0);
-                                     &resource_loader,
+    let mode = RendererMode::default_for_device(&device);
-                                     DestFramebuffer::full_window(window_size),
+    let options = RendererOptions {
-                                     RendererOptions {
+        background_color: Some(ColorF::white()),
-                                         background_color: Some(ColorF::white()),
+        dest: DestFramebuffer::full_window(window_size),
-                                         ..RendererOptions::default()
+        ..RendererOptions::default()
-                                     });
+    };
+    let mut renderer = Renderer::new(device, &resource_loader, mode, options);
 
     // Load a font.
     let font_data = Arc::new(resource_loader.slurp("fonts/Overpass-Regular.otf").unwrap());
@@ -74,7 +75,9 @@ fn main() {
     canvas.stroke_text("Goodbye Pathfinder!", vec2f(608.0, 464.0));
 
     // Render the canvas to screen.
-    let scene = SceneProxy::from_scene(canvas.into_canvas().into_scene(), RayonExecutor);
+    let mut scene = SceneProxy::from_scene(canvas.into_canvas().into_scene(),
+                                           renderer.mode().level,
+                                           RayonExecutor);
     scene.build_and_render(&mut renderer, BuildOptions::default());
     window.gl_swap_window();
 

examples/swf_basic/src/main.rs

@@ -15,7 +15,7 @@ use pathfinder_gl::{GLDevice, GLVersion};
 use pathfinder_renderer::concurrent::rayon::RayonExecutor;
 use pathfinder_renderer::concurrent::scene_proxy::SceneProxy;
 use pathfinder_renderer::gpu::renderer::Renderer;
-use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererOptions};
+use pathfinder_renderer::gpu::options::{DestFramebuffer, RendererMode, RendererOptions};
 use pathfinder_renderer::options::{RenderTransform, BuildOptions};
 use pathfinder_resources::ResourceLoader;
 use pathfinder_resources::embedded::EmbeddedResourceLoader;
@@ -98,15 +98,15 @@ fn main() {
     window.gl_make_current(&gl_context).unwrap();
 
     // Create a Pathfinder renderer.
-    let mut renderer = Renderer::new(
+    let device = GLDevice::new(GLVersion::GL3, 0);
-        GLDevice::new(GLVersion::GL3, 0),
+    let mode = RendererMode::default_for_device(&device);
-        &resource_loader,
+    let options = RendererOptions {
-        DestFramebuffer::full_window(pixel_size),
+        background_color: Some(stage.background_color()),
-        RendererOptions {
+        dest: DestFramebuffer::full_window(pixel_size),
-            background_color: Some(stage.background_color()),
+        ..RendererOptions::default()
-            ..RendererOptions::default()
+    };
-        }
+    let mut renderer = Renderer::new(device, &resource_loader, mode, options);
-    );
+
     // Clear to swf stage background color.
     let mut scene = Scene::new();
     scene.set_view_box(RectF::new(Vector2F::zero(),
@@ -115,7 +115,7 @@ fn main() {
     draw_paths_into_scene(&library, &mut scene);
 
     // Render the canvas to screen.
-    let scene = SceneProxy::from_scene(scene, RayonExecutor);
+    let mut scene = SceneProxy::from_scene(scene, renderer.mode().level, RayonExecutor);
     let mut build_options = BuildOptions::default();
     let scale_transform = Transform2F::from_scale(device_pixel_ratio);
     build_options.transform = RenderTransform::Transform2D(scale_transform);