Updated to new PF3 API

demo/magicleap/src/lib.rs

@@ -10,30 +10,30 @@ use gl::types::GLuint;
 
 use log::info;
 
-use pathfinder_demo::Background;
 use pathfinder_demo::DemoApp;
 use pathfinder_demo::Options;
 use pathfinder_demo::UIVisibility;
+use pathfinder_demo::BackgroundColor;
+use pathfinder_demo::Mode;
 use pathfinder_demo::window::Event;
-use pathfinder_demo::window::Mode;
 use pathfinder_demo::window::SVGPath;
-use pathfinder_geometry::basic::point::Point2DI32;
 use pathfinder_geometry::basic::point::Point2DF32;
+use pathfinder_geometry::basic::point::Point2DI32;
 use pathfinder_geometry::basic::rect::RectI32;
 use pathfinder_geometry::basic::transform2d::Transform2DF32;
 use pathfinder_gl::GLDevice;
 use pathfinder_gl::GLVersion;
 use pathfinder_gpu::Device;
 use pathfinder_gpu::resources::FilesystemResourceLoader;
-use pathfinder_renderer::gpu::renderer::Renderer;
+use pathfinder_gpu::resources::ResourceLoader;
-use pathfinder_simd::default::F32x4;
-use pathfinder_renderer::z_buffer::ZBuffer;
-use pathfinder_renderer::gpu_data::BuiltScene;
-use pathfinder_renderer::builder::SceneBuilder;
 use pathfinder_renderer::builder::RenderOptions;
 use pathfinder_renderer::builder::RenderTransform;
+use pathfinder_renderer::builder::SceneBuilder;
+use pathfinder_renderer::builder::SceneBuilderContext;
+use pathfinder_renderer::gpu::renderer::Renderer;
+use pathfinder_renderer::gpu_data::BuiltScene;
+use pathfinder_simd::default::F32x4;
 use pathfinder_svg::BuiltSVG;
-use pathfinder_gpu::resources::ResourceLoader;
 
 use std::collections::HashMap;
 use std::ffi::CStr;
@@ -59,7 +59,9 @@ struct ImmersiveApp {
 
 #[no_mangle]
 pub extern "C" fn magicleap_pathfinder_demo_init(egl_display: EGLDisplay, egl_context: EGLContext) -> *mut c_void {
-    unsafe { c_api::MLLoggingLog(c_api::MLLogLevel::Info, &b"Pathfinder Demo\0"[0], &b"Initializing\0"[0]) };
+    unsafe { c_api::MLLoggingLog(c_api::MLLogLevel::Info,
+                                 b"Pathfinder Demo\0".as_ptr() as *const _,
+                                 b"Initializing\0".as_ptr() as *const _) };
 
     let tag = CString::new("Pathfinder Demo").unwrap();
     let level = log::LevelFilter::Warn;
@@ -72,11 +74,10 @@ pub extern "C" fn magicleap_pathfinder_demo_init(egl_display: EGLDisplay, egl_co
     let window_size = window.size();
 
     let mut options = Options::default();
-    options.ui = UIVisibility::None;
+    options.ui = UIVisibility::Stats;
-    options.background = Background::None;
+    options.background_color = BackgroundColor::Transparent;
     options.mode = Mode::VR;
     options.jobs = Some(3);
-    options.pipeline = false;
     
     let demo = DemoApp::new(window, window_size, options);
     info!("Initialized app");
@@ -102,7 +103,7 @@ pub unsafe extern "C" fn magicleap_pathfinder_demo_run(app: *mut c_void) {
                 app.demo.draw_scene(scene_index);
             }
             app.demo.finish_drawing_frame();
-	}
+        }
     }
 }
 
@@ -120,6 +121,7 @@ struct MagicLeapPathfinder {
     renderers: HashMap<(EGLSurface, EGLDisplay), Renderer<GLDevice>>,
     svgs: HashMap<String, BuiltSVG>,
     resources: FilesystemResourceLoader,
+    scene_builder_context: SceneBuilderContext,
 }
 
 #[repr(C)]
@@ -133,7 +135,9 @@ pub struct MagicLeapPathfinderRenderOptions {
 
 #[no_mangle]
 pub extern "C" fn magicleap_pathfinder_init() -> *mut c_void {
-    unsafe { c_api::MLLoggingLog(c_api::MLLogLevel::Info, &b"Pathfinder Demo\0"[0], &b"Initializing\0"[0]) };
+    unsafe { c_api::MLLoggingLog(c_api::MLLogLevel::Info,
+                                 b"Pathfinder Demo\0".as_ptr() as *const _,
+                                 b"Initializing\0".as_ptr() as *const _) };
 
     let tag = CString::new("Pathfinder Demo").unwrap();
     let level = log::LevelFilter::Info;
@@ -149,6 +153,7 @@ pub extern "C" fn magicleap_pathfinder_init() -> *mut c_void {
         renderers: HashMap::new(),
         svgs: HashMap::new(),
         resources: FilesystemResourceLoader::locate(),
+        scene_builder_context: SceneBuilderContext::new(),
     };
     info!("Initialized pf");
 
@@ -162,71 +167,76 @@ pub unsafe extern "C" fn magicleap_pathfinder_render(pf: *mut c_void, options: *
         let resources = &pf.resources;
 
         let svg_filename = CStr::from_ptr(options.svg_filename).to_string_lossy().into_owned();
-	let svg = pf.svgs.entry(svg_filename).or_insert_with(|| {
+        let svg = pf.svgs.entry(svg_filename).or_insert_with(|| {
             let svg_filename = CStr::from_ptr(options.svg_filename).to_string_lossy();
-	    let data = resources.slurp(&*svg_filename).unwrap();
+            let data = resources.slurp(&*svg_filename).unwrap();
-	    let tree = Tree::from_data(&data, &UsvgOptions::default()).unwrap();
+            let tree = Tree::from_data(&data, &UsvgOptions::default()).unwrap();
             BuiltSVG::from_tree(tree)
         });
 
         let mut width = 0;
-    	let mut height = 0;
+            let mut height = 0;
-	egl::query_surface(options.display, options.surface, egl::EGL_WIDTH, &mut width);
+        egl::query_surface(options.display, options.surface, egl::EGL_WIDTH, &mut width);
-	egl::query_surface(options.display, options.surface, egl::EGL_HEIGHT, &mut height);
+        egl::query_surface(options.display, options.surface, egl::EGL_HEIGHT, &mut height);
         let size = Point2DI32::new(width, height);
 
         let viewport_origin = Point2DI32::new(options.viewport[0] as i32, options.viewport[1] as i32);
-	let viewport_size = Point2DI32::new(options.viewport[2] as i32, options.viewport[3] as i32);
+        let viewport_size = Point2DI32::new(options.viewport[2] as i32, options.viewport[3] as i32);
         let viewport = RectI32::new(viewport_origin, viewport_size);
 
-	let renderer = pf.renderers.entry((options.display, options.surface)).or_insert_with(|| {
+        let bg_color = F32x4::new(options.bg_color[0], options.bg_color[1], options.bg_color[2], options.bg_color[3]);
-   	    let mut fbo = 0;
+
-  	    gl::GetIntegerv(gl::DRAW_FRAMEBUFFER_BINDING, &mut fbo);
+        let renderer = pf.renderers.entry((options.display, options.surface)).or_insert_with(|| {
+               let mut fbo = 0;
+              gl::GetIntegerv(gl::DRAW_FRAMEBUFFER_BINDING, &mut fbo);
             let device = GLDevice::new(GLVersion::GLES3, fbo as GLuint);
             Renderer::new(device, resources, viewport, size)
         });
 
-        let bg_color = F32x4::new(options.bg_color[0], options.bg_color[1], options.bg_color[2], options.bg_color[3]);
-
-        svg.scene.view_box = viewport.to_f32();
         renderer.set_main_framebuffer_size(size);
         renderer.set_viewport(viewport);
-	renderer.device.bind_default_framebuffer(viewport);
+        renderer.device.bind_default_framebuffer(viewport);
         renderer.device.clear(Some(bg_color), Some(1.0), Some(0));
         renderer.disable_depth();
 
-        let z_buffer = ZBuffer::new(svg.scene.view_box);
+        svg.scene.view_box = viewport.to_f32();
 
         let scale = i32::min(viewport_size.x(), viewport_size.y()) as f32 /
-	    f32::max(svg.scene.bounds.size().x(), svg.scene.bounds.size().y());
+            f32::max(svg.scene.bounds.size().x(), svg.scene.bounds.size().y());
         let transform = Transform2DF32::from_translation(&svg.scene.bounds.size().scale(-0.5))
-	    .post_mul(&Transform2DF32::from_scale(&Point2DF32::splat(scale)))
+            .post_mul(&Transform2DF32::from_scale(&Point2DF32::splat(scale)))
             .post_mul(&Transform2DF32::from_translation(&viewport_size.to_f32().scale(0.5)));
-	    
+            
         let render_options = RenderOptions {
             transform: RenderTransform::Transform2D(transform),
             dilation: Point2DF32::default(),
             barrel_distortion: None,
-	    subpixel_aa_enabled: false,
+            subpixel_aa_enabled: false,
-	};
+        };
 
         let built_options = render_options.prepare(svg.scene.bounds);
         let quad = built_options.quad();
-        let built_objects = svg.scene.build_objects(built_options, &z_buffer);
-        let mut scene_builder = SceneBuilder::new(built_objects, z_buffer, svg.scene.view_box);
-        let mut built_scene = BuiltScene::new(svg.scene.view_box, &quad, svg.scene.objects.len() as u32);
 
+        let mut built_scene = BuiltScene::new(svg.scene.view_box, &quad, svg.scene.objects.len() as u32);
         built_scene.shaders = svg.scene.build_shaders();
-        built_scene.solid_tiles = scene_builder.build_solid_tiles();
+
-        while let Some(batch) = scene_builder.build_batch() {
+        let (command_sender, command_receiver) = mpsc::channel();
-            built_scene.batches.push(batch);
+        let command_sender_clone = command_sender.clone();
+
+        SceneBuilder::new(&pf.scene_builder_context, &svg.scene, &built_options)
+            .build_sequentially(Box::new(move |command| { let _ = command_sender.send(Some(command)); }));
+
+        let _ = command_sender_clone.send(None);
+        
+        renderer.begin_scene(&built_scene);
+        while let Ok(Some(command)) = command_receiver.recv() {
+            renderer.render_command(&command);
         }
-	
+        renderer.end_scene();
-        renderer.render_scene(&built_scene);
     }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn magicleap_pathfinder_deinit(pf: *mut c_void) {
     Box::from_raw(pf as *mut MagicLeapPathfinder);
-}
+}

demo/magicleap/src/magicleap.rs

@@ -45,7 +45,7 @@ use log::info;
 
 use pathfinder_demo::window::CameraTransform;
 use pathfinder_demo::window::Event;
-use pathfinder_demo::window::Mode;
+use pathfinder_demo::window::View;
 use pathfinder_demo::window::Window;
 use pathfinder_demo::window::WindowSize;
 use pathfinder_geometry::basic::point::Point2DI32;
@@ -121,19 +121,19 @@ impl Window for MagicLeapWindow {
         Err(())
     }
 
-    fn view_box_size(&self, _mode: Mode) -> Point2DI32 {
+    fn viewport(&self, _view: View) -> RectI32 {
-        self.size
+        RectI32::new(Point2DI32::default(), self.size)
     }
 
     fn barrel_distortion_coefficients(&self) -> BarrelDistortionCoefficients {
         BarrelDistortionCoefficients { k0: 0.0, k1: 0.0 }
     }
 
-    fn make_current(&mut self, _mode: Mode, eye: Option<u32>) -> RectI32 {
+    fn make_current(&mut self, view: View) {
         self.begin_frame();
-        let eye = match eye {
+        let eye = match view {
-            Some(eye) if (eye as usize) < ML_VIRTUAL_CAMERA_COUNT => eye as usize,
+            View::Stereo(eye) if (eye as usize) < ML_VIRTUAL_CAMERA_COUNT => eye as usize,
-            _ => { debug!("Asked for eye out of range {:?}", eye); 0 }
+            _ => { debug!("Asked for unexpected view: {:?}", view); 0 }
         };
         debug!("Making {} current.", eye);
         let viewport = self.virtual_camera_array.viewport;
@@ -147,7 +147,6 @@ impl Window for MagicLeapWindow {
             gl::Viewport(viewport.x as i32, viewport.y as i32, viewport.w as i32, viewport.h as i32);
         }
         debug!("Made {} current.", eye);
-        RectI32::new(Point2DI32::new(0, 0), self.size)
     }
 
     fn present(&mut self) {