use std::ffi::c_void;
use std::mem::ManuallyDrop;
use std::sync::{Arc, RwLock};
use super::Renderer;
use crate::cameras::Camera;
use crate::scene::Scene;
pub struct LayerGpu {
instance: wgpu::Instance,
adapter: wgpu::Adapter,
device: ManuallyDrop<Arc<wgpu::Device>>,
queue: ManuallyDrop<Arc<wgpu::Queue>>,
frames: Arc<RwLock<()>>,
}
impl LayerGpu {
pub fn new() -> Result<Self, String> {
let _pool = Pool::new();
let mut d = wgpu::InstanceDescriptor::new_without_display_handle();
d.backends = wgpu::Backends::METAL;
let instance = wgpu::Instance::new(d);
let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
compatible_surface: None,
force_fallback_adapter: false,
apply_limit_buckets: false,
}))
.map_err(|e| format!("no Metal adapter: {e}"))?;
let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
label: Some("threers layer device"),
required_features: wgpu::Features::empty(),
required_limits: adapter.limits(),
..Default::default()
}))
.map_err(|e| format!("wgpu request_device failed: {e:?}"))?;
Ok(Self {
instance,
adapter,
device: ManuallyDrop::new(Arc::new(device)),
queue: ManuallyDrop::new(Arc::new(queue)),
frames: Arc::new(RwLock::new(())),
})
}
pub fn device(&self) -> &Arc<wgpu::Device> {
&self.device
}
pub fn queue(&self) -> &Arc<wgpu::Queue> {
&self.queue
}
}
pub struct LayerRenderer {
surface: ManuallyDrop<wgpu::Surface<'static>>,
config: wgpu::SurfaceConfiguration,
device: Arc<wgpu::Device>,
instance: wgpu::Instance,
layer: usize,
alpha_modes: Vec<wgpu::CompositeAlphaMode>,
frames: Arc<RwLock<()>>,
unconfigured: bool,
renderer: ManuallyDrop<Renderer>,
}
impl Drop for LayerGpu {
fn drop(&mut self) {
let _pool = Pool::new();
unsafe {
ManuallyDrop::drop(&mut self.queue);
ManuallyDrop::drop(&mut self.device);
}
}
}
impl Drop for LayerRenderer {
fn drop(&mut self) {
let _pool = Pool::new();
unsafe {
ManuallyDrop::drop(&mut self.renderer);
ManuallyDrop::drop(&mut self.surface);
}
}
}
const _: () = {
const fn send_sync<T: Send + Sync>() {}
const fn send<T: Send>() {}
send_sync::<LayerGpu>();
send::<LayerRenderer>();
};
pub(crate) struct Pool(*mut c_void);
impl Pool {
pub(crate) fn new() -> Self {
Self(unsafe { objc_autoreleasePoolPush() })
}
}
impl Drop for Pool {
fn drop(&mut self) {
unsafe { objc_autoreleasePoolPop(self.0) }
}
}
#[link(name = "objc", kind = "dylib")]
unsafe extern "C" {
fn objc_autoreleasePoolPush() -> *mut c_void;
fn objc_autoreleasePoolPop(pool: *mut c_void);
}
fn is_metal_layer(layer: *mut c_void) -> bool {
use std::ffi::c_char;
#[repr(C)]
struct Object {
_private: [u8; 0],
}
#[link(name = "objc", kind = "dylib")]
unsafe extern "C" {
fn objc_getClass(name: *const c_char) -> *mut Object;
fn sel_registerName(name: *const c_char) -> *const c_void;
fn objc_msgSend();
}
if layer.is_null() {
return false;
}
unsafe {
let cls = objc_getClass(c"CAMetalLayer".as_ptr());
if cls.is_null() {
return false;
}
let is_kind: unsafe extern "C" fn(*mut c_void, *const c_void, *mut Object) -> i8 =
std::mem::transmute(objc_msgSend as unsafe extern "C" fn());
is_kind(layer, sel_registerName(c"isKindOfClass:".as_ptr()), cls) != 0
}
}
impl LayerRenderer {
pub unsafe fn new(gpu: &LayerGpu, layer: *mut c_void, width: u32, height: u32, msaa: u32) -> Result<Self, String> {
let _pool = Pool::new();
if !is_metal_layer(layer) {
return Err("not a CAMetalLayer — on iOS, override the view's `layerClass` \
to return `CAMetalLayer.self`"
.into());
}
let (width, height) = (width.max(1), height.max(1));
let surface = unsafe { gpu
.instance
.create_surface_unsafe(wgpu::SurfaceTargetUnsafe::CoreAnimationLayer(layer)) }
.map_err(|e| format!("layer surface: {e:?}"))?;
let caps = surface.get_capabilities(&gpu.adapter);
let format = caps.formats.iter().copied().find(|f| f.is_srgb()).unwrap_or(caps.formats[0]);
let alpha_mode = [wgpu::CompositeAlphaMode::Opaque, wgpu::CompositeAlphaMode::Auto]
.into_iter()
.find(|m| caps.alpha_modes.contains(m))
.unwrap_or(caps.alpha_modes[0]);
let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format,
width,
height,
present_mode: wgpu::PresentMode::Fifo,
alpha_mode,
view_formats: vec![],
desired_maximum_frame_latency: 2,
color_space: wgpu::SurfaceColorSpace::Srgb,
};
let mut renderer = Renderer::new(Arc::clone(&gpu.device), Arc::clone(&gpu.queue), format, width, height);
renderer.set_msaa(msaa);
let mut this = Self {
surface: ManuallyDrop::new(surface),
config,
device: Arc::clone(&gpu.device),
instance: gpu.instance.clone(),
layer: layer as usize,
alpha_modes: caps.alpha_modes.clone(),
frames: gpu.frames.clone(),
unconfigured: true,
renderer: ManuallyDrop::new(renderer),
};
this.configure();
Ok(this)
}
pub fn resize(&mut self, width: u32, height: u32) {
let (width, height) = (width.max(1), height.max(1));
if (width, height) == (self.config.width, self.config.height) {
return;
}
let _pool = Pool::new();
self.config.width = width;
self.config.height = height;
self.configure();
self.renderer.resize(width, height);
}
fn configure(&mut self) -> bool {
let _alone = self.frames.write().unwrap_or_else(|e| e.into_inner());
let scope = self.device.push_error_scope(wgpu::ErrorFilter::Validation);
self.surface.configure(&self.device, &self.config);
self.unconfigured = pollster::block_on(scope.pop()).is_some();
!self.unconfigured
}
pub fn size(&self) -> (u32, u32) {
(self.config.width, self.config.height)
}
pub fn set_transparent(&mut self, on: bool) -> bool {
let want: &[wgpu::CompositeAlphaMode] = if on {
&[wgpu::CompositeAlphaMode::PreMultiplied, wgpu::CompositeAlphaMode::PostMultiplied]
} else {
&[wgpu::CompositeAlphaMode::Opaque, wgpu::CompositeAlphaMode::Auto]
};
let Some(mode) = want.iter().copied().find(|m| self.alpha_modes.contains(m)) else {
return false;
};
if mode != self.config.alpha_mode {
let _pool = Pool::new();
self.config.alpha_mode = mode;
self.configure();
}
true
}
pub fn render(&mut self, scene: &mut Scene, camera: &dyn Camera) -> bool {
self.present(|renderer, view| renderer.render(scene, camera, view, false))
}
#[cfg(feature = "xr")]
pub fn render_xr(
&mut self,
scene: &mut Scene,
lens: &crate::cameras::PerspectiveCamera,
source: &impl crate::xr::XrSource,
origin: &crate::math::Matrix4,
) -> bool {
let mut drawn = false;
let presented = self.present(|renderer, view| drawn = renderer.render_xr(scene, lens, source, origin, view));
presented && drawn
}
pub fn draw_with(&mut self, draw: impl FnOnce(&mut Renderer, &wgpu::TextureView, wgpu::TextureFormat)) -> bool {
let format = self.config.format;
self.present(|renderer, view| draw(renderer, view, format))
}
fn present(&mut self, draw: impl FnOnce(&mut Renderer, &wgpu::TextureView)) -> bool {
use wgpu::CurrentSurfaceTexture as Acquired;
let _pool = Pool::new();
if self.unconfigured && !self.configure() {
return false;
}
match self.surface.get_current_texture() {
Acquired::Success(frame) => {
self.draw(draw, frame);
true
}
Acquired::Suboptimal(frame) => {
self.draw(draw, frame);
self.unconfigured = true;
true
}
Acquired::Timeout | Acquired::Occluded => false,
Acquired::Outdated => {
self.configure();
false
}
Acquired::Lost => {
let target = wgpu::SurfaceTargetUnsafe::CoreAnimationLayer(self.layer as *mut c_void);
if let Ok(surface) = unsafe { self.instance.create_surface_unsafe(target) } {
*self.surface = surface;
}
self.configure();
false
}
_ => false,
}
}
fn draw(&mut self, draw: impl FnOnce(&mut Renderer, &wgpu::TextureView), frame: wgpu::SurfaceTexture) {
let _frame = self.frames.read().unwrap_or_else(|e| e.into_inner());
let view = frame.texture.create_view(&wgpu::TextureViewDescriptor::default());
draw(&mut self.renderer, &view);
self.renderer.queue_arc().present(frame);
}
pub fn renderer(&mut self) -> &mut Renderer {
&mut self.renderer
}
}