2019-04-09 15:41:15 -04:00
|
|
|
use crate::magicleap::MagicLeapLandscape;
|
2019-03-09 12:57:44 -05:00
|
|
|
use crate::magicleap::MagicLeapLogger;
|
|
|
|
use crate::magicleap::MagicLeapWindow;
|
|
|
|
|
|
|
|
use egl;
|
|
|
|
use egl::EGLContext;
|
|
|
|
use egl::EGLDisplay;
|
2019-04-09 15:41:15 -04:00
|
|
|
use egl::EGLSurface;
|
2019-03-09 12:57:44 -05:00
|
|
|
|
2019-04-09 15:33:33 -04:00
|
|
|
use gl::types::GLuint;
|
|
|
|
|
2019-03-09 12:57:44 -05:00
|
|
|
use log::debug;
|
2019-04-09 15:41:15 -04:00
|
|
|
use log::info;
|
2019-03-09 12:57:44 -05:00
|
|
|
|
|
|
|
use pathfinder_demo::Background;
|
|
|
|
use pathfinder_demo::DemoApp;
|
|
|
|
use pathfinder_demo::Options;
|
2019-04-09 15:41:15 -04:00
|
|
|
use pathfinder_demo::window::Event;
|
2019-03-09 12:57:44 -05:00
|
|
|
use pathfinder_demo::window::Mode;
|
2019-04-09 15:41:15 -04:00
|
|
|
use pathfinder_demo::window::SVGPath;
|
|
|
|
use pathfinder_demo::window::WindowSize;
|
|
|
|
use pathfinder_geometry::basic::point::Point2DI32;
|
2019-04-09 15:33:33 -04:00
|
|
|
use pathfinder_geometry::basic::point::Point2DF32;
|
|
|
|
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_simd::default::F32x4;
|
|
|
|
use pathfinder_renderer::scene::Scene;
|
|
|
|
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_svg::BuiltSVG;
|
|
|
|
use pathfinder_gpu::resources::ResourceLoader;
|
|
|
|
|
|
|
|
use rayon::ThreadPoolBuilder;
|
2019-03-09 12:57:44 -05:00
|
|
|
|
2019-04-09 15:33:33 -04:00
|
|
|
use std::collections::HashMap;
|
2019-04-09 15:41:15 -04:00
|
|
|
use std::ffi::CStr;
|
2019-03-09 12:57:44 -05:00
|
|
|
use std::ffi::CString;
|
2019-03-29 16:28:16 -04:00
|
|
|
use std::os::raw::c_char;
|
2019-04-09 15:41:15 -04:00
|
|
|
use std::os::raw::c_void;
|
2019-03-09 12:57:44 -05:00
|
|
|
|
2019-04-09 15:33:33 -04:00
|
|
|
use usvg::Options as UsvgOptions;
|
|
|
|
use usvg::Tree;
|
|
|
|
|
2019-03-09 12:57:44 -05:00
|
|
|
mod c_api;
|
|
|
|
mod magicleap;
|
|
|
|
|
|
|
|
#[cfg(feature = "mocked")]
|
|
|
|
mod mocked_c_api;
|
|
|
|
|
|
|
|
#[no_mangle]
|
2019-04-04 13:55:24 -04:00
|
|
|
pub unsafe extern "C" fn magicleap_pathfinder_demo(egl_display: EGLDisplay, egl_context: EGLContext, file_name: *const c_char) {
|
2019-03-09 12:57:44 -05:00
|
|
|
unsafe { c_api::MLLoggingLog(c_api::MLLogLevel::Info, &b"Pathfinder Demo\0"[0], &b"Initializing\0"[0]) };
|
|
|
|
|
|
|
|
let tag = CString::new("Pathfinder Demo").unwrap();
|
|
|
|
let level = log::LevelFilter::Warn;
|
|
|
|
let logger = MagicLeapLogger::new(tag, level);
|
|
|
|
log::set_boxed_logger(Box::new(logger)).unwrap();
|
|
|
|
log::set_max_level(level);
|
|
|
|
debug!("Initialized logging");
|
|
|
|
|
|
|
|
let window = MagicLeapWindow::new(egl_display, egl_context);
|
|
|
|
let window_size = window.size();
|
|
|
|
|
|
|
|
let mut options = Options::default();
|
|
|
|
options.ui = false;
|
|
|
|
options.background = Background::None;
|
|
|
|
options.mode = Mode::VR;
|
2019-03-28 15:36:27 -04:00
|
|
|
options.jobs = Some(3);
|
2019-03-28 12:22:22 -04:00
|
|
|
options.pipeline = 0;
|
2019-04-04 13:55:24 -04:00
|
|
|
if let Some(file_name) = file_name.as_ref() {
|
|
|
|
let file_name = CStr::from_ptr(file_name).to_string_lossy().into_owned();
|
|
|
|
options.input_path = SVGPath::Resource(file_name);
|
|
|
|
}
|
|
|
|
|
2019-03-09 12:57:44 -05:00
|
|
|
let mut app = DemoApp::new(window, window_size, options);
|
|
|
|
debug!("Initialized app");
|
|
|
|
|
|
|
|
while app.window.running() {
|
|
|
|
let mut events = Vec::new();
|
|
|
|
while let Some(event) = app.window.try_get_event() {
|
|
|
|
events.push(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
let scene_count = app.prepare_frame(events);
|
|
|
|
for scene_index in 0..scene_count {
|
|
|
|
app.draw_scene(scene_index);
|
|
|
|
}
|
|
|
|
app.finish_drawing_frame();
|
|
|
|
}
|
2019-03-29 16:28:16 -04:00
|
|
|
}
|
|
|
|
|
2019-04-09 15:33:33 -04:00
|
|
|
struct MagicLeapPathfinder {
|
2019-04-04 12:21:41 -04:00
|
|
|
renderers: HashMap<(EGLSurface, EGLDisplay), Renderer<GLDevice>>,
|
|
|
|
svgs: HashMap<String, BuiltSVG>,
|
2019-04-09 15:33:33 -04:00
|
|
|
resources: FilesystemResourceLoader,
|
|
|
|
}
|
|
|
|
|
|
|
|
struct MagicLeapPathfinderSurface {
|
|
|
|
surf: EGLSurface,
|
|
|
|
size: Point2DI32,
|
|
|
|
viewport: RectI32,
|
|
|
|
bg_color: F32x4,
|
|
|
|
renderer: Renderer<GLDevice>,
|
|
|
|
scene: Scene,
|
|
|
|
}
|
|
|
|
|
2019-04-04 12:21:41 -04:00
|
|
|
#[repr(C)]
|
|
|
|
pub struct MagicLeapPathfinderRenderOptions {
|
|
|
|
display: EGLDisplay,
|
|
|
|
surface: EGLSurface,
|
|
|
|
bg_color: [f32; 4],
|
|
|
|
viewport: [u32; 4],
|
|
|
|
svg_filename: *const c_char,
|
|
|
|
}
|
|
|
|
|
2019-04-09 15:41:15 -04:00
|
|
|
#[no_mangle]
|
2019-04-04 12:21:41 -04:00
|
|
|
pub extern "C" fn magicleap_pathfinder_init() -> *mut c_void {
|
2019-04-09 15:41:15 -04:00
|
|
|
unsafe { c_api::MLLoggingLog(c_api::MLLogLevel::Info, &b"Pathfinder Demo\0"[0], &b"Initializing\0"[0]) };
|
|
|
|
|
|
|
|
let tag = CString::new("Pathfinder Demo").unwrap();
|
|
|
|
let level = log::LevelFilter::Info;
|
|
|
|
let logger = MagicLeapLogger::new(tag, level);
|
|
|
|
log::set_boxed_logger(Box::new(logger)).unwrap();
|
|
|
|
log::set_max_level(level);
|
|
|
|
info!("Initialized logging");
|
|
|
|
|
2019-04-09 15:33:33 -04:00
|
|
|
let mut thread_pool_builder = ThreadPoolBuilder::new()
|
|
|
|
.build_global().unwrap();
|
|
|
|
info!("Initialized rayon");
|
|
|
|
|
|
|
|
gl::load_with(|s| egl::get_proc_address(s) as *const c_void);
|
|
|
|
info!("Initialized gl");
|
2019-04-09 15:41:15 -04:00
|
|
|
|
2019-04-09 15:33:33 -04:00
|
|
|
let pf = MagicLeapPathfinder {
|
2019-04-04 12:21:41 -04:00
|
|
|
renderers: HashMap::new(),
|
|
|
|
svgs: HashMap::new(),
|
2019-04-09 15:33:33 -04:00
|
|
|
resources: FilesystemResourceLoader::locate(),
|
|
|
|
};
|
|
|
|
info!("Initialized pf");
|
|
|
|
|
|
|
|
Box::into_raw(Box::new(pf)) as *mut c_void
|
2019-04-09 15:41:15 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
#[no_mangle]
|
2019-04-04 12:21:41 -04:00
|
|
|
pub unsafe extern "C" fn magicleap_pathfinder_render(pf: *mut c_void, options: *const MagicLeapPathfinderRenderOptions) {
|
2019-04-09 15:33:33 -04:00
|
|
|
let pf = pf as *mut MagicLeapPathfinder;
|
2019-04-04 12:21:41 -04:00
|
|
|
if let (Some(pf), Some(options)) = (pf.as_mut(), options.as_ref()) {
|
2019-04-09 15:33:33 -04:00
|
|
|
let resources = &pf.resources;
|
2019-04-04 12:21:41 -04:00
|
|
|
|
|
|
|
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_filename = CStr::from_ptr(options.svg_filename).to_string_lossy();
|
2019-04-09 15:33:33 -04:00
|
|
|
let data = resources.slurp(&*svg_filename).unwrap();
|
2019-04-04 12:21:41 -04:00
|
|
|
let tree = Tree::from_data(&data, &UsvgOptions::default()).unwrap();
|
|
|
|
BuiltSVG::from_tree(tree)
|
|
|
|
});
|
|
|
|
|
|
|
|
let mut width = 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_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 = RectI32::new(viewport_origin, viewport_size);
|
|
|
|
|
|
|
|
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.clear(Some(bg_color), Some(1.0), Some(0));
|
|
|
|
renderer.disable_depth();
|
|
|
|
|
|
|
|
let z_buffer = ZBuffer::new(svg.scene.view_box);
|
|
|
|
|
|
|
|
let scale = i32::min(viewport_size.x(), viewport_size.y()) as f32 /
|
|
|
|
f32::max(svg.scene.bounds.size().x(), svg.scene.bounds.size().y());
|
|
|
|
let transform = Transform2DF32::from_translation(&svg.scene.bounds.size().scale(-0.5))
|
2019-04-09 15:33:33 -04:00
|
|
|
.post_mul(&Transform2DF32::from_scale(&Point2DF32::splat(scale)))
|
2019-04-04 12:21:41 -04:00
|
|
|
.post_mul(&Transform2DF32::from_translation(&viewport_size.to_f32().scale(0.5)));
|
2019-04-09 15:33:33 -04:00
|
|
|
|
|
|
|
let render_options = RenderOptions {
|
|
|
|
transform: RenderTransform::Transform2D(transform),
|
|
|
|
dilation: Point2DF32::default(),
|
|
|
|
barrel_distortion: None,
|
|
|
|
};
|
|
|
|
|
2019-04-04 12:21:41 -04:00
|
|
|
let built_options = render_options.prepare(svg.scene.bounds);
|
2019-04-09 15:33:33 -04:00
|
|
|
let quad = built_options.quad();
|
2019-04-04 12:21:41 -04:00
|
|
|
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);
|
2019-04-09 15:33:33 -04:00
|
|
|
|
2019-04-04 12:21:41 -04:00
|
|
|
built_scene.shaders = svg.scene.build_shaders();
|
2019-04-09 15:33:33 -04:00
|
|
|
built_scene.solid_tiles = scene_builder.build_solid_tiles();
|
|
|
|
while let Some(batch) = scene_builder.build_batch() {
|
|
|
|
built_scene.batches.push(batch);
|
|
|
|
}
|
|
|
|
|
2019-04-04 12:21:41 -04:00
|
|
|
renderer.render_scene(&built_scene);
|
2019-04-09 15:41:15 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[no_mangle]
|
2019-04-09 15:33:33 -04:00
|
|
|
pub unsafe extern "C" fn magicleap_pathfinder_deinit(pf: *mut c_void) {
|
|
|
|
Box::from_raw(pf as *mut MagicLeapPathfinder);
|
2019-03-09 12:57:44 -05:00
|
|
|
}
|