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

Updated magicleap demo for new pathfinder API

This commit is contained in:
Alan Jeffrey 2019-06-03 17:32:35 -05:00
parent a2c8d71a3f
commit 848234ef61
3 changed files with 66 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
demo/magicleap/src/lib.rs
View File

@ -20,6 +20,7 @@ use egl::EGLSurface;
use gl::types::GLuint; use gl::types::GLuint;
use log::debug;
use log::info; use log::info;
use pathfinder_demo::DemoApp; use pathfinder_demo::DemoApp;
@ -29,20 +30,23 @@ use pathfinder_demo::BackgroundColor;
use pathfinder_demo::Mode; use pathfinder_demo::Mode;
use pathfinder_demo::window::Event; use pathfinder_demo::window::Event;
use pathfinder_demo::window::SVGPath; use pathfinder_demo::window::SVGPath;
use pathfinder_geometry::basic::point::Point2DF32; use pathfinder_geometry::basic::point::Point2DF;
use pathfinder_geometry::basic::point::Point2DI32; use pathfinder_geometry::basic::point::Point2DI;
use pathfinder_geometry::basic::rect::RectI32; use pathfinder_geometry::basic::rect::RectI;
use pathfinder_geometry::basic::transform2d::Transform2DF32; use pathfinder_geometry::basic::transform2d::Transform2DF;
use pathfinder_geometry::color::ColorF;
use pathfinder_gl::GLDevice; use pathfinder_gl::GLDevice;
use pathfinder_gl::GLVersion; use pathfinder_gl::GLVersion;
use pathfinder_gpu::ClearParams;
use pathfinder_gpu::Device; use pathfinder_gpu::Device;
use pathfinder_gpu::resources::FilesystemResourceLoader; use pathfinder_gpu::resources::FilesystemResourceLoader;
use pathfinder_gpu::resources::ResourceLoader; use pathfinder_gpu::resources::ResourceLoader;
use pathfinder_renderer::builder::RenderOptions; use pathfinder_renderer::concurrent::executor::SequentialExecutor;
use pathfinder_renderer::builder::RenderTransform; use pathfinder_renderer::concurrent::scene_proxy::SceneProxy;
use pathfinder_renderer::builder::SceneBuilder;
use pathfinder_renderer::gpu::renderer::Renderer; use pathfinder_renderer::gpu::renderer::Renderer;
use pathfinder_renderer::gpu::renderer::DestFramebuffer; use pathfinder_renderer::gpu::renderer::DestFramebuffer;
use pathfinder_renderer::options::RenderOptions;
use pathfinder_renderer::options::RenderTransform;
use pathfinder_simd::default::F32x4; use pathfinder_simd::default::F32x4;
use pathfinder_svg::BuiltSVG; use pathfinder_svg::BuiltSVG;
@ -109,8 +113,9 @@ pub unsafe extern "C" fn magicleap_pathfinder_demo_run(app: *mut c_void) {
events.push(event); events.push(event);
} }
let scene_count = app.demo.prepare_frame(events); let scene_count = app.demo.prepare_frame(events);
app.demo.draw_scene();
for scene_index in 0..scene_count { for scene_index in 0..scene_count {
app.demo.draw_scene(scene_index); app.demo.composite_scene(scene_index);
} }
app.demo.finish_drawing_frame(); app.demo.finish_drawing_frame();
} }
@ -186,14 +191,13 @@ pub unsafe extern "C" fn magicleap_pathfinder_render(pf: *mut c_void, options: *
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 size = Point2DI::new(width, height);
let viewport_origin = Point2DI32::new(options.viewport[0] as i32, options.viewport[1] as i32); let viewport_origin = Point2DI::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 = Point2DI::new(options.viewport[2] as i32, options.viewport[3] as i32);
let viewport = RectI32::new(viewport_origin, viewport_size); let viewport = RectI::new(viewport_origin, viewport_size);
let dest_framebuffer = DestFramebuffer::Default { viewport, window_size: size };
let bg_color = F32x4::new(options.bg_color[0], options.bg_color[1], options.bg_color[2], options.bg_color[3]); let bg_color = ColorF(F32x4::new(options.bg_color[0], options.bg_color[1], options.bg_color[2], options.bg_color[3]));
let renderer = pf.renderers.entry((options.display, options.surface)).or_insert_with(|| { let renderer = pf.renderers.entry((options.display, options.surface)).or_insert_with(|| {
let mut fbo = 0; let mut fbo = 0;
@ -204,41 +208,26 @@ pub unsafe extern "C" fn magicleap_pathfinder_render(pf: *mut c_void, options: *
}); });
renderer.set_main_framebuffer_size(size); renderer.set_main_framebuffer_size(size);
renderer.set_dest_framebuffer(dest_framebuffer);
renderer.device.bind_default_framebuffer(viewport); renderer.device.bind_default_framebuffer(viewport);
renderer.device.clear(Some(bg_color), Some(1.0), Some(0)); renderer.device.clear(&ClearParams { color: Some(bg_color), ..ClearParams::default() });
renderer.disable_depth(); renderer.disable_depth();
svg.scene.view_box = viewport.to_f32(); svg.scene.set_view_box(viewport.to_f32());
let scale = i32::min(viewport_size.x(), viewport_size.y()) as 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)) let transform = Transform2DF::from_translation(svg.scene.bounds().size().scale(-0.5))
.post_mul(&Transform2DF32::from_scale(&Point2DF32::splat(scale))) .post_mul(&Transform2DF::from_scale(Point2DF::splat(scale)))
.post_mul(&Transform2DF32::from_translation(&viewport_size.to_f32().scale(0.5))); .post_mul(&Transform2DF::from_translation(viewport_size.to_f32().scale(0.5)));
let render_options = RenderOptions { let render_options = RenderOptions {
transform: RenderTransform::Transform2D(transform), transform: RenderTransform::Transform2D(transform),
dilation: Point2DF32::default(), dilation: Point2DF::default(),
barrel_distortion: None,
subpixel_aa_enabled: false, subpixel_aa_enabled: false,
}; };
let built_options = render_options.prepare(svg.scene.bounds); let scene_proxy = SceneProxy::from_scene(svg.scene.clone(), SequentialExecutor);
scene_proxy.build_and_render(renderer, render_options);
let (command_sender, command_receiver) = crossbeam_channel::unbounded();
let command_sender_clone = command_sender.clone();
SceneBuilder::new(&svg.scene, &built_options, Box::new(move |command| { let _ = command_sender.send(Some(command)); }))
.build_sequentially();
let _ = command_sender_clone.send(None);
renderer.begin_scene(&svg.scene.build_descriptor(&built_options));
while let Ok(Some(command)) = command_receiver.recv() {
renderer.render_command(&command);
}
renderer.end_scene();
} }
} }

77
demo/magicleap/src/magicleap.rs
View File

@ -42,19 +42,19 @@ use gl::types::GLuint;
use log; use log;
use log::debug; use log::debug;
use log::info; use log::info;
use log::warn;
use pathfinder_demo::window::CameraTransform;
use pathfinder_demo::window::Event; use pathfinder_demo::window::Event;
use pathfinder_demo::window::OcularTransform;
use pathfinder_demo::window::View; use pathfinder_demo::window::View;
use pathfinder_demo::window::Window; use pathfinder_demo::window::Window;
use pathfinder_demo::window::WindowSize; use pathfinder_demo::window::WindowSize;
use pathfinder_geometry::basic::point::Point2DI32; use pathfinder_geometry::basic::point::Point2DI;
use pathfinder_geometry::basic::point::Point2DF32; use pathfinder_geometry::basic::point::Point2DF;
use pathfinder_geometry::basic::rect::RectF32; use pathfinder_geometry::basic::rect::RectF;
use pathfinder_geometry::basic::rect::RectI32; use pathfinder_geometry::basic::rect::RectI;
use pathfinder_geometry::basic::transform3d::Perspective; use pathfinder_geometry::basic::transform3d::Perspective;
use pathfinder_geometry::basic::transform3d::Transform3DF32; use pathfinder_geometry::basic::transform3d::Transform3DF;
use pathfinder_geometry::distortion::BarrelDistortionCoefficients;
use pathfinder_geometry::util; use pathfinder_geometry::util;
use pathfinder_gl::GLVersion; use pathfinder_gl::GLVersion;
use pathfinder_gpu::resources::FilesystemResourceLoader; use pathfinder_gpu::resources::FilesystemResourceLoader;
@ -76,12 +76,12 @@ use std::time::Duration;
pub struct MagicLeapWindow { pub struct MagicLeapWindow {
framebuffer_id: GLuint, framebuffer_id: GLuint,
graphics_client: MLHandle, graphics_client: MLHandle,
size: Point2DI32, size: Point2DI,
virtual_camera_array: MLGraphicsVirtualCameraInfoArray, virtual_camera_array: MLGraphicsVirtualCameraInfoArray,
initial_camera_transform: Option<Transform3DF32>, initial_camera_transform: Option<Transform3DF>,
frame_handle: MLHandle, frame_handle: MLHandle,
resource_loader: FilesystemResourceLoader, resource_loader: FilesystemResourceLoader,
pose_event: Option<Vec<CameraTransform>>, pose_event: Option<Vec<OcularTransform>>,
running: bool, running: bool,
in_frame: bool, in_frame: bool,
} }
@ -103,10 +103,6 @@ impl Window for MagicLeapWindow {
thread_pool_builder.start_handler(|id| unsafe { init_scene_thread(id) }) thread_pool_builder.start_handler(|id| unsafe { init_scene_thread(id) })
} }
fn mouse_position(&self) -> Point2DI32 {
Point2DI32::new(0, 0)
}
fn create_user_event_id (&self) -> u32 { fn create_user_event_id (&self) -> u32 {
0 0
} }
@ -121,12 +117,8 @@ impl Window for MagicLeapWindow {
Err(()) Err(())
} }
fn viewport(&self, _view: View) -> RectI32 { fn viewport(&self, _view: View) -> RectI {
RectI32::new(Point2DI32::default(), self.size) RectI::new(Point2DI::default(), self.size)
}
fn barrel_distortion_coefficients(&self) -> BarrelDistortionCoefficients {
BarrelDistortionCoefficients { k0: 0.0, k1: 0.0 }
} }
fn make_current(&mut self, view: View) { fn make_current(&mut self, view: View) {
@ -142,6 +134,7 @@ impl Window for MagicLeapWindow {
let virtual_camera = self.virtual_camera_array.virtual_cameras[eye]; let virtual_camera = self.virtual_camera_array.virtual_cameras[eye];
let layer_id = virtual_camera.virtual_camera_name as i32; let layer_id = virtual_camera.virtual_camera_name as i32;
unsafe { unsafe {
gl::BindFramebuffer(gl::FRAMEBUFFER, self.framebuffer_id);
gl::FramebufferTextureLayer(gl::FRAMEBUFFER, gl::COLOR_ATTACHMENT0, color_id, 0, layer_id); gl::FramebufferTextureLayer(gl::FRAMEBUFFER, gl::COLOR_ATTACHMENT0, color_id, 0, layer_id);
gl::FramebufferTextureLayer(gl::FRAMEBUFFER, gl::DEPTH_ATTACHMENT, depth_id, 0, layer_id); gl::FramebufferTextureLayer(gl::FRAMEBUFFER, gl::DEPTH_ATTACHMENT, depth_id, 0, layer_id);
gl::Viewport(viewport.x as i32, viewport.y as i32, viewport.w as i32, viewport.h as i32); gl::Viewport(viewport.x as i32, viewport.y as i32, viewport.w as i32, viewport.h as i32);
@ -192,7 +185,7 @@ impl MagicLeapWindow {
MagicLeapWindow { MagicLeapWindow {
framebuffer_id, framebuffer_id,
graphics_client, graphics_client,
size: Point2DI32::new(max_width, max_height), size: Point2DI::new(max_width, max_height),
frame_handle: ML_HANDLE_INVALID, frame_handle: ML_HANDLE_INVALID,
virtual_camera_array, virtual_camera_array,
initial_camera_transform: None, initial_camera_transform: None,
@ -215,12 +208,12 @@ impl MagicLeapWindow {
} }
pub fn try_get_event(&mut self) -> Option<Event> { pub fn try_get_event(&mut self) -> Option<Event> {
self.pose_event.take().map(Event::CameraTransforms) self.pose_event.take().map(Event::SetEyeTransforms)
} }
fn begin_frame(&mut self) { fn begin_frame(&mut self) {
if !self.in_frame { if !self.in_frame {
debug!("PF beginning frame"); debug!("PF beginning frame");
let mut params = unsafe { mem::zeroed() }; let mut params = unsafe { mem::zeroed() };
unsafe { unsafe {
gl::BindFramebuffer(gl::FRAMEBUFFER, self.framebuffer_id); gl::BindFramebuffer(gl::FRAMEBUFFER, self.framebuffer_id);
@ -242,22 +235,22 @@ impl MagicLeapWindow {
} }
let virtual_camera_array = &self.virtual_camera_array; let virtual_camera_array = &self.virtual_camera_array;
let initial_camera = self.initial_camera_transform.get_or_insert_with(|| { let initial_camera = self.initial_camera_transform.get_or_insert_with(|| {
let initial_offset = Transform3DF32::from_translation(0.0, 0.0, 1.0); let initial_offset = Transform3DF::from_translation(0.0, 0.0, 1.0);
let mut camera = virtual_camera_array.virtual_cameras[0].transform; let mut camera = virtual_camera_array.virtual_cameras[0].transform;
for i in 1..virtual_camera_array.num_virtual_cameras { for i in 1..virtual_camera_array.num_virtual_cameras {
let next = virtual_camera_array.virtual_cameras[i as usize].transform; let next = virtual_camera_array.virtual_cameras[i as usize].transform;
camera = camera.lerp(next, 1.0 / (i as f32 + 1.0)); camera = camera.lerp(next, 1.0 / (i as f32 + 1.0));
} }
Transform3DF32::from(camera).post_mul(&initial_offset) Transform3DF::from(camera).post_mul(&initial_offset)
}); });
let camera_transforms = (0..virtual_camera_array.num_virtual_cameras) let camera_transforms = (0..virtual_camera_array.num_virtual_cameras)
.map(|i| { .map(|i| {
let camera = &virtual_camera_array.virtual_cameras[i as usize]; let camera = &virtual_camera_array.virtual_cameras[i as usize];
let projection = Transform3DF32::from(camera.projection); let projection = Transform3DF::from(camera.projection);
let size = RectI32::from(virtual_camera_array.viewport).size(); let size = RectI::from(virtual_camera_array.viewport).size();
let perspective = Perspective::new(&projection, size); let perspective = Perspective::new(&projection, size);
let view = Transform3DF32::from(camera.transform).inverse().post_mul(initial_camera); let modelview_to_eye = Transform3DF::from(camera.transform).inverse().post_mul(initial_camera);
CameraTransform { perspective, view } OcularTransform { perspective, modelview_to_eye }
}) })
.collect(); .collect();
self.in_frame = true; self.in_frame = true;
@ -363,41 +356,41 @@ impl MLTransform {
// Impl pathfinder traits for c-api types // Impl pathfinder traits for c-api types
impl From<MLTransform> for Transform3DF32 { impl From<MLTransform> for Transform3DF {
fn from(mat: MLTransform) -> Self { fn from(mat: MLTransform) -> Self {
Transform3DF32::from(mat.rotation) Transform3DF::from(mat.rotation)
.pre_mul(&Transform3DF32::from(mat.position)) .pre_mul(&Transform3DF::from(mat.position))
} }
} }
impl From<MLVec3f> for Transform3DF32 { impl From<MLVec3f> for Transform3DF {
fn from(v: MLVec3f) -> Self { fn from(v: MLVec3f) -> Self {
Transform3DF32::from_translation(v.x, v.y, v.z) Transform3DF::from_translation(v.x, v.y, v.z)
} }
} }
impl From<MLRectf> for RectF32 { impl From<MLRectf> for RectF {
fn from(r: MLRectf) -> Self { fn from(r: MLRectf) -> Self {
RectF32::new(Point2DF32::new(r.x, r.y), Point2DF32::new(r.w, r.h)) RectF::new(Point2DF::new(r.x, r.y), Point2DF::new(r.w, r.h))
} }
} }
impl From<MLRectf> for RectI32 { impl From<MLRectf> for RectI {
fn from(r: MLRectf) -> Self { fn from(r: MLRectf) -> Self {
RectF32::from(r).to_i32() RectF::from(r).to_i32()
} }
} }
impl From<MLQuaternionf> for Transform3DF32 { impl From<MLQuaternionf> for Transform3DF {
fn from(q: MLQuaternionf) -> Self { fn from(q: MLQuaternionf) -> Self {
Transform3DF32::from_rotation_quaternion(F32x4::new(q.x, q.y, q.z, q.w)) Transform3DF::from_rotation_quaternion(F32x4::new(q.x, q.y, q.z, q.w))
} }
} }
impl From<MLMat4f> for Transform3DF32 { impl From<MLMat4f> for Transform3DF {
fn from(mat: MLMat4f) -> Self { fn from(mat: MLMat4f) -> Self {
let a = mat.matrix_colmajor; let a = mat.matrix_colmajor;
Transform3DF32::row_major(a[0], a[4], a[8], a[12], Transform3DF::row_major(a[0], a[4], a[8], a[12],
a[1], a[5], a[9], a[13], a[1], a[5], a[9], a[13],
a[2], a[6], a[10], a[14], a[2], a[6], a[10], a[14],
a[3], a[7], a[11], a[15]) a[3], a[7], a[11], a[15])

4
demo/magicleap/src/main.cpp
View File

@ -228,7 +228,11 @@ int main() {
} }
// Initialize pathfinder // Initialize pathfinder
ML_LOG(Info, "%s: Initializing demo.", application_name);
void* app = magicleap_pathfinder_demo_init(graphics_context.egl_display, graphics_context.egl_context); void* app = magicleap_pathfinder_demo_init(graphics_context.egl_display, graphics_context.egl_context);
if (!app) {
ML_LOG(Error, "%s: Failed to initialize demo.", application_name);
}
// let system know our app has started // let system know our app has started
MLLifecycleCallbacks lifecycle_callbacks = {}; MLLifecycleCallbacks lifecycle_callbacks = {};