use std::ffi::c_void;
use super::super::device::{MetalDevice, MetalError};
use super::super::enums::{MTLViewport, NSUInteger};
use super::super::objc::{msg0, sel, AutoreleasePool, Id, NIL};
use super::super::renderer::{MetalRenderStats, MetalRenderer, PassAttachments, RenderView};
use super::{
ArDataProviders, ArDeviceAnchor, ArSession, ArWorldTrackingConfiguration,
ArWorldTrackingProvider, AxisConvention, CpDrawable, CpFrame, CpFrameTiming, CpLayerRenderer,
CpLayerRendererProperties, CpTime, CpView, CpViewTextureMap, LayerRendererState, SimdFloat2,
SimdFloat4x4,
};
use crate::math::Matrix4;
use crate::scene::Scene;
pub(crate) unsafe fn call_returning_float4x4(f: unsafe extern "C" fn(), x0: usize, x1: usize, x2: usize) -> SimdFloat4x4 {
use std::arch::aarch64::float32x4_t;
let (c0, c1, c2, c3): (float32x4_t, float32x4_t, float32x4_t, float32x4_t);
unsafe {
std::arch::asm!(
"blr {f}",
f = in(reg) f,
inout("x0") x0 => _,
inout("x1") x1 => _,
inout("x2") x2 => _,
out("v0") c0,
out("v1") c1,
out("v2") c2,
out("v3") c3,
clobber_abi("C"),
);
SimdFloat4x4 { columns: std::mem::transmute::<[float32x4_t; 4], [[f32; 4]; 4]>([c0, c1, c2, c3]) }
}
}
fn float2_bits(v: SimdFloat2) -> f64 {
f64::from_bits(((v.y.to_bits() as u64) << 32) | v.x.to_bits() as u64)
}
pub(crate) unsafe fn cp_drawable_set_depth_range(drawable: CpDrawable, depth_range: SimdFloat2) {
unsafe { cp_drawable_set_depth_range_raw(drawable, float2_bits(depth_range)) }
}
pub(crate) unsafe fn cp_drawable_compute_projection(drawable: CpDrawable, convention: u8, view_index: NSUInteger) -> SimdFloat4x4 {
unsafe { call_returning_float4x4(cp_drawable_compute_projection_sym, drawable as usize, convention as usize, view_index) }
}
pub(crate) unsafe fn cp_view_get_transform(view: CpView) -> SimdFloat4x4 {
unsafe { call_returning_float4x4(cp_view_get_transform_sym, view as usize, 0, 0) }
}
pub(crate) unsafe fn ar_device_anchor_get_origin_from_anchor_transform(anchor: ArDeviceAnchor) -> SimdFloat4x4 {
unsafe { call_returning_float4x4(ar_device_anchor_get_origin_from_anchor_transform_sym, anchor as usize, 0, 0) }
}
#[link(name = "CompositorServices", kind = "framework")]
unsafe extern "C" {
pub(crate) fn cp_layer_renderer_get_state(layer_renderer: CpLayerRenderer) -> u32;
pub(crate) fn cp_layer_renderer_wait_until_running(layer_renderer: CpLayerRenderer);
pub(crate) fn cp_layer_renderer_query_next_frame(layer_renderer: CpLayerRenderer) -> CpFrame;
pub(crate) fn cp_layer_renderer_get_device(layer_renderer: CpLayerRenderer) -> Id;
pub(crate) fn cp_layer_renderer_get_properties(
layer_renderer: CpLayerRenderer,
) -> CpLayerRendererProperties;
pub(crate) fn cp_layer_renderer_properties_get_view_count(
properties: CpLayerRendererProperties,
) -> NSUInteger;
pub(crate) fn cp_frame_predict_timing(frame: CpFrame) -> CpFrameTiming;
pub(crate) fn cp_frame_start_update(frame: CpFrame);
pub(crate) fn cp_frame_end_update(frame: CpFrame);
pub(crate) fn cp_frame_start_submission(frame: CpFrame);
pub(crate) fn cp_frame_end_submission(frame: CpFrame);
pub(crate) fn cp_frame_query_drawable(frame: CpFrame) -> CpDrawable;
pub(crate) fn cp_frame_timing_get_optimal_input_time(timing: CpFrameTiming) -> CpTime;
pub(crate) fn cp_frame_timing_get_presentation_time(timing: CpFrameTiming) -> CpTime;
pub(crate) fn cp_time_wait_until(time: CpTime);
pub(crate) fn cp_time_to_cf_time_interval(time: CpTime) -> f64;
pub(crate) fn cp_drawable_get_view_count(drawable: CpDrawable) -> NSUInteger;
pub(crate) fn cp_drawable_get_view(drawable: CpDrawable, index: NSUInteger) -> CpView;
pub(crate) fn cp_drawable_get_color_texture(drawable: CpDrawable, index: NSUInteger) -> Id;
pub(crate) fn cp_drawable_get_depth_texture(drawable: CpDrawable, index: NSUInteger) -> Id;
pub(crate) fn cp_drawable_get_frame_timing(drawable: CpDrawable) -> CpFrameTiming;
pub(crate) fn cp_drawable_set_device_anchor(drawable: CpDrawable, device_anchor: ArDeviceAnchor);
#[link_name = "cp_drawable_set_depth_range"]
fn cp_drawable_set_depth_range_raw(drawable: CpDrawable, depth_range: f64);
#[link_name = "cp_drawable_compute_projection"]
fn cp_drawable_compute_projection_sym();
pub(crate) fn cp_drawable_encode_present(drawable: CpDrawable, command_buffer: Id);
#[link_name = "cp_view_get_transform"]
fn cp_view_get_transform_sym();
pub(crate) fn cp_view_get_view_texture_map(view: CpView) -> CpViewTextureMap;
pub(crate) fn cp_view_texture_map_get_texture_index(map: CpViewTextureMap) -> NSUInteger;
pub(crate) fn cp_view_texture_map_get_slice_index(map: CpViewTextureMap) -> NSUInteger;
pub(crate) fn cp_view_texture_map_get_viewport(map: CpViewTextureMap) -> MTLViewport;
}
#[link(name = "ARKit", kind = "framework")]
unsafe extern "C" {
pub(crate) fn ar_session_create() -> ArSession;
pub(crate) fn ar_session_run(session: ArSession, data_providers: ArDataProviders);
pub(crate) fn ar_world_tracking_configuration_create() -> ArWorldTrackingConfiguration;
pub(crate) fn ar_world_tracking_provider_create(
configuration: ArWorldTrackingConfiguration,
) -> ArWorldTrackingProvider;
pub(crate) fn ar_world_tracking_provider_query_device_anchor_at_timestamp(
provider: ArWorldTrackingProvider,
timestamp: f64,
device_anchor: ArDeviceAnchor,
) -> isize;
pub(crate) fn ar_data_providers_create() -> ArDataProviders;
pub(crate) fn ar_data_providers_add_data_provider(providers: ArDataProviders, provider: *mut c_void);
pub(crate) fn ar_device_anchor_create() -> ArDeviceAnchor;
#[link_name = "ar_device_anchor_get_origin_from_anchor_transform"]
fn ar_device_anchor_get_origin_from_anchor_transform_sym();
pub(crate) fn ar_release(object: *mut c_void);
}
struct ArObject(*mut c_void);
impl ArObject {
fn new(ptr: *mut c_void) -> Option<Self> {
(!ptr.is_null()).then_some(Self(ptr))
}
fn ptr(&self) -> *mut c_void {
self.0
}
}
impl Drop for ArObject {
fn drop(&mut self) {
unsafe { ar_release(self.0) }
}
}
pub struct WorldTracking {
_session: ArObject,
provider: ArObject,
anchor: ArObject,
}
impl WorldTracking {
pub fn new() -> Result<Self, MetalError> {
Self::with_providers(&[])
}
pub(crate) fn with_providers(extra: &[*mut c_void]) -> Result<Self, MetalError> {
unsafe {
let configuration = ArObject::new(ar_world_tracking_configuration_create())
.ok_or_else(|| MetalError::Unsupported("ar_world_tracking_configuration".into()))?;
let provider = ArObject::new(ar_world_tracking_provider_create(configuration.ptr()))
.ok_or_else(|| MetalError::Unsupported("ar_world_tracking_provider".into()))?;
let providers = ArObject::new(ar_data_providers_create())
.ok_or_else(|| MetalError::Unsupported("ar_data_providers".into()))?;
ar_data_providers_add_data_provider(providers.ptr(), provider.ptr());
for &p in extra {
ar_data_providers_add_data_provider(providers.ptr(), p);
}
let session = ArObject::new(ar_session_create())
.ok_or_else(|| MetalError::Unsupported("ar_session".into()))?;
ar_session_run(session.ptr(), providers.ptr());
let anchor = ArObject::new(ar_device_anchor_create())
.ok_or_else(|| MetalError::Unsupported("ar_device_anchor".into()))?;
Ok(Self {
_session: session,
provider,
anchor,
})
}
}
pub fn device_pose(&self, timestamp: f64) -> Option<Matrix4> {
unsafe {
let status = ar_world_tracking_provider_query_device_anchor_at_timestamp(
self.provider.ptr(),
timestamp,
self.anchor.ptr(),
);
(status == 0).then(|| {
ar_device_anchor_get_origin_from_anchor_transform(self.anchor.ptr()).into()
})
}
}
pub(crate) fn anchor_ptr(&self) -> ArDeviceAnchor {
self.anchor.ptr()
}
}
const MIN_NEAR: f32 = 0.1;
pub struct ImmersiveFrame<'a> {
pub head: Option<Matrix4>,
pub views: &'a [RenderView],
pub size: (u32, u32),
}
pub struct ImmersiveRenderer {
layer: CpLayerRenderer,
device: MetalDevice,
renderer: MetalRenderer,
tracking: Option<WorldTracking>,
convention: AxisConvention,
near: f32,
far: f32,
origin: Matrix4,
last_stats: MetalRenderStats,
}
impl ImmersiveRenderer {
pub unsafe fn new(layer_renderer: *mut c_void) -> Result<Self, MetalError> {
if layer_renderer.is_null() {
return Err(MetalError::Unsupported("null cp_layer_renderer_t".into()));
}
let mtl_device = unsafe { cp_layer_renderer_get_device(layer_renderer) };
let device = unsafe { MetalDevice::adopt(mtl_device) }?;
let renderer = MetalRenderer::with_device(device.clone())?;
let tracking = WorldTracking::new().ok();
Ok(Self {
layer: layer_renderer,
device,
renderer,
tracking,
convention: AxisConvention::RightUpBack,
near: MIN_NEAR,
far: 1000.0,
origin: Matrix4::identity(),
last_stats: MetalRenderStats::default(),
})
}
pub fn state(&self) -> LayerRendererState {
LayerRendererState::from_raw(unsafe { cp_layer_renderer_get_state(self.layer) })
}
pub fn wait_until_running(&self) {
unsafe { cp_layer_renderer_wait_until_running(self.layer) }
}
pub fn view_count(&self) -> usize {
unsafe {
let properties = cp_layer_renderer_get_properties(self.layer);
if properties.is_null() {
return 2;
}
cp_layer_renderer_properties_get_view_count(properties)
}
}
pub fn set_depth_range(&mut self, near: f32, far: f32) {
self.near = near.max(MIN_NEAR);
self.far = far.max(self.near + 0.001);
}
pub fn depth_range(&self) -> (f32, f32) {
(self.near, self.far)
}
pub fn set_axis_convention(&mut self, convention: AxisConvention) {
self.convention = convention;
}
pub fn set_origin(&mut self, origin: Matrix4) {
self.origin = origin;
}
pub fn is_world_tracked(&self) -> bool {
self.tracking.is_some()
}
pub fn stats(&self) -> MetalRenderStats {
self.last_stats
}
pub fn renderer_mut(&mut self) -> &mut MetalRenderer {
&mut self.renderer
}
pub fn render_frame(&mut self, scene: &mut Scene) -> Result<bool, MetalError> {
self.render_frame_with(scene, |_, _| {})
}
pub fn render_frame_with(
&mut self,
scene: &mut Scene,
update: impl FnOnce(&mut Scene, &ImmersiveFrame),
) -> Result<bool, MetalError> {
match self.state() {
LayerRendererState::Invalidated => return Ok(false),
LayerRendererState::Paused => {
self.wait_until_running();
return Ok(true);
}
LayerRendererState::Running => {}
}
let _pool = AutoreleasePool::new();
unsafe {
let frame = cp_layer_renderer_query_next_frame(self.layer);
if frame.is_null() {
return Ok(true);
}
let timing = cp_frame_predict_timing(frame);
if !timing.is_null() {
cp_time_wait_until(cp_frame_timing_get_optimal_input_time(timing));
}
cp_frame_start_update(frame);
cp_frame_end_update(frame);
cp_frame_start_submission(frame);
let drawable = cp_frame_query_drawable(frame);
if drawable.is_null() {
cp_frame_end_submission(frame);
return Ok(true);
}
cp_drawable_set_depth_range(
drawable,
SimdFloat2 {
x: self.far,
y: self.near,
},
);
let head = self.update_device_anchor(drawable);
let origin_from_device = head.unwrap_or_else(Matrix4::identity);
let views = self.views(drawable, &origin_from_device);
let pass = self.attachments(drawable);
update(scene, &ImmersiveFrame { head, views: &views, size: pass.size() });
let stats = self.renderer.render_views(scene, &views, &pass)?;
self.last_stats = stats;
let command_buffer = self.device.command_buffer();
if !command_buffer.is_null() {
cp_drawable_encode_present(drawable, command_buffer);
let _: () = msg0(command_buffer, sel!("commit"));
}
cp_frame_end_submission(frame);
}
Ok(true)
}
unsafe fn update_device_anchor(&self, drawable: CpDrawable) -> Option<Matrix4> {
let tracking = self.tracking.as_ref()?;
let timing = unsafe { cp_drawable_get_frame_timing(drawable) };
if timing.is_null() {
return None;
}
let presentation =
unsafe { cp_time_to_cf_time_interval(cp_frame_timing_get_presentation_time(timing)) };
let pose = tracking.device_pose(presentation)?;
unsafe { cp_drawable_set_device_anchor(drawable, tracking.anchor_ptr()) };
Some(pose)
}
unsafe fn views(&self, drawable: CpDrawable, origin_from_device: &Matrix4) -> Vec<RenderView> {
let count = unsafe { cp_drawable_get_view_count(drawable) }.min(super::super::MAX_VIEWS);
let mut views = Vec::with_capacity(count);
for index in 0..count {
let view = unsafe { cp_drawable_get_view(drawable, index) };
if view.is_null() {
continue;
}
let device_from_eye: Matrix4 = unsafe { cp_view_get_transform(view) }.into();
let world_from_eye = self.origin.multiply(&origin_from_device.multiply(&device_from_eye));
let projection: Matrix4 =
unsafe { cp_drawable_compute_projection(drawable, self.convention as u8, index) }
.into();
let mut render_view = RenderView::from_matrices(world_from_eye.invert(), projection);
let map = unsafe { cp_view_get_view_texture_map(view) };
if !map.is_null() {
render_view.slice = unsafe { cp_view_texture_map_get_slice_index(map) } as u32;
let viewport = unsafe { cp_view_texture_map_get_viewport(map) };
render_view.viewport = Some(viewport);
let texture_index = unsafe { cp_view_texture_map_get_texture_index(map) };
if texture_index != 0 {
render_view.color =
unsafe { cp_drawable_get_color_texture(drawable, texture_index) };
render_view.depth =
unsafe { cp_drawable_get_depth_texture(drawable, texture_index) };
}
}
views.push(render_view);
}
views
}
unsafe fn attachments(&self, drawable: CpDrawable) -> PassAttachments {
let color = unsafe { cp_drawable_get_color_texture(drawable, 0) };
let depth = unsafe { cp_drawable_get_depth_texture(drawable, 0) };
let (width, height) = unsafe { texture_size(color) };
unsafe {
PassAttachments::from_raw(
color,
NIL,
depth,
NIL,
width,
height,
texture_pixel_format(color),
texture_pixel_format(depth),
1,
)
}
.with_reverse_z(true)
}
pub fn device(&self) -> &MetalDevice {
&self.device
}
}
unsafe fn texture_size(texture: Id) -> (u32, u32) {
if texture.is_null() {
return (0, 0);
}
let width: NSUInteger = unsafe { msg0(texture, sel!("width")) };
let height: NSUInteger = unsafe { msg0(texture, sel!("height")) };
(width as u32, height as u32)
}
unsafe fn texture_pixel_format(texture: Id) -> NSUInteger {
if texture.is_null() {
return 0;
}
unsafe { msg0(texture, sel!("pixelFormat")) }
}