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;
#[link(name = "CompositorServices", kind = "framework")]
extern "C" {
fn cp_layer_renderer_get_state(layer_renderer: CpLayerRenderer) -> u32;
fn cp_layer_renderer_wait_until_running(layer_renderer: CpLayerRenderer);
fn cp_layer_renderer_query_next_frame(layer_renderer: CpLayerRenderer) -> CpFrame;
fn cp_layer_renderer_get_device(layer_renderer: CpLayerRenderer) -> Id;
fn cp_layer_renderer_get_properties(
layer_renderer: CpLayerRenderer,
) -> CpLayerRendererProperties;
fn cp_layer_renderer_properties_get_view_count(
properties: CpLayerRendererProperties,
) -> NSUInteger;
fn cp_frame_predict_timing(frame: CpFrame) -> CpFrameTiming;
fn cp_frame_start_update(frame: CpFrame);
fn cp_frame_end_update(frame: CpFrame);
fn cp_frame_start_submission(frame: CpFrame);
fn cp_frame_end_submission(frame: CpFrame);
fn cp_frame_query_drawable(frame: CpFrame) -> CpDrawable;
fn cp_frame_timing_get_optimal_input_time(timing: CpFrameTiming) -> CpTime;
fn cp_frame_timing_get_presentation_time(timing: CpFrameTiming) -> CpTime;
fn cp_time_wait_until(time: CpTime);
fn cp_time_to_cf_time_interval(time: CpTime) -> f64;
fn cp_drawable_get_view_count(drawable: CpDrawable) -> NSUInteger;
fn cp_drawable_get_view(drawable: CpDrawable, index: NSUInteger) -> CpView;
fn cp_drawable_get_color_texture(drawable: CpDrawable, index: NSUInteger) -> Id;
fn cp_drawable_get_depth_texture(drawable: CpDrawable, index: NSUInteger) -> Id;
fn cp_drawable_get_frame_timing(drawable: CpDrawable) -> CpFrameTiming;
fn cp_drawable_set_device_anchor(drawable: CpDrawable, device_anchor: ArDeviceAnchor);
fn cp_drawable_set_depth_range(drawable: CpDrawable, depth_range: SimdFloat2);
fn cp_drawable_compute_projection(
drawable: CpDrawable,
convention: u8,
view_index: NSUInteger,
) -> SimdFloat4x4;
fn cp_drawable_encode_present(drawable: CpDrawable, command_buffer: Id);
fn cp_view_get_transform(view: CpView) -> SimdFloat4x4;
fn cp_view_get_view_texture_map(view: CpView) -> CpViewTextureMap;
fn cp_view_texture_map_get_texture_index(map: CpViewTextureMap) -> NSUInteger;
fn cp_view_texture_map_get_slice_index(map: CpViewTextureMap) -> NSUInteger;
fn cp_view_texture_map_get_viewport(map: CpViewTextureMap) -> MTLViewport;
}
#[link(name = "ARKit", kind = "framework")]
extern "C" {
fn ar_session_create() -> ArSession;
fn ar_session_run(session: ArSession, data_providers: ArDataProviders);
fn ar_world_tracking_configuration_create() -> ArWorldTrackingConfiguration;
fn ar_world_tracking_provider_create(
configuration: ArWorldTrackingConfiguration,
) -> ArWorldTrackingProvider;
fn ar_world_tracking_provider_query_device_anchor_at_timestamp(
provider: ArWorldTrackingProvider,
timestamp: f64,
device_anchor: ArDeviceAnchor,
) -> isize;
fn ar_data_providers_create() -> ArDataProviders;
fn ar_data_providers_add_data_provider(providers: ArDataProviders, provider: *mut c_void);
fn ar_device_anchor_create() -> ArDeviceAnchor;
fn ar_device_anchor_get_origin_from_anchor_transform(anchor: ArDeviceAnchor) -> SimdFloat4x4;
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> {
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());
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()
})
}
}
fn anchor_ptr(&self) -> ArDeviceAnchor {
self.anchor.ptr()
}
}
pub struct ImmersiveRenderer {
layer: CpLayerRenderer,
device: MetalDevice,
renderer: MetalRenderer,
tracking: Option<WorldTracking>,
convention: AxisConvention,
near: f32,
far: f32,
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 = cp_layer_renderer_get_device(layer_renderer);
let device = 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: 0.01,
far: 1000.0,
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(0.001);
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 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> {
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 origin_from_device = self.update_device_anchor(drawable);
let views = self.views(drawable, &origin_from_device);
let pass = self.attachments(drawable);
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) -> Matrix4 {
let Some(tracking) = &self.tracking else {
return Matrix4::identity();
};
let timing = cp_drawable_get_frame_timing(drawable);
if timing.is_null() {
return Matrix4::identity();
}
let presentation =
cp_time_to_cf_time_interval(cp_frame_timing_get_presentation_time(timing));
match tracking.device_pose(presentation) {
Some(pose) => {
cp_drawable_set_device_anchor(drawable, tracking.anchor_ptr());
pose
}
None => Matrix4::identity(),
}
}
unsafe fn views(&self, drawable: CpDrawable, origin_from_device: &Matrix4) -> Vec<RenderView> {
let count = 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 = cp_drawable_get_view(drawable, index);
if view.is_null() {
continue;
}
let device_from_eye: Matrix4 = cp_view_get_transform(view).into();
let world_from_eye = origin_from_device.multiply(&device_from_eye);
let projection: Matrix4 =
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 = cp_view_get_view_texture_map(view);
if !map.is_null() {
render_view.slice = cp_view_texture_map_get_slice_index(map) as u32;
let viewport = cp_view_texture_map_get_viewport(map);
render_view.viewport = Some(viewport);
let texture_index = cp_view_texture_map_get_texture_index(map);
if texture_index != 0 {
render_view.color = cp_drawable_get_color_texture(drawable, texture_index);
render_view.depth = cp_drawable_get_depth_texture(drawable, texture_index);
}
}
views.push(render_view);
}
views
}
unsafe fn attachments(&self, drawable: CpDrawable) -> PassAttachments {
let color = cp_drawable_get_color_texture(drawable, 0);
let depth = cp_drawable_get_depth_texture(drawable, 0);
let (width, height) = texture_size(color);
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 = msg0(texture, sel!("width"));
let height: NSUInteger = msg0(texture, sel!("height"));
(width as u32, height as u32)
}
unsafe fn texture_pixel_format(texture: Id) -> NSUInteger {
if texture.is_null() {
return 0;
}
msg0(texture, sel!("pixelFormat"))
}