use std::collections::HashSet;
use std::sync::{Arc, Mutex};
use crate::cameras::Camera;
use crate::metal::enums::pixel_format;
use crate::metal::{MetalHeadlessRenderer, SsaoSettings};
use crate::scene::Scene;
pub(super) fn requested(backend: super::RenderBackend) -> bool {
match backend {
super::RenderBackend::Metal => true,
super::RenderBackend::Wgpu => false,
super::RenderBackend::Auto => {
std::env::var("THREERS_BACKEND").is_ok_and(|v| v.eq_ignore_ascii_case("metal"))
}
}
}
pub(super) fn warn_fallback(reason: &str) {
static SAID: Mutex<Option<HashSet<String>>> = Mutex::new(None);
let mut said = SAID.lock().unwrap_or_else(|e| e.into_inner());
if said.get_or_insert_with(HashSet::new).insert(reason.to_string()) {
eprintln!("threers: THREERS_BACKEND=metal: {reason} needs wgpu; drawing with wgpu from here");
}
}
const UNCONFIRMED_NOTE: u32 = 120;
pub(super) struct MetalPath {
hr: MetalHeadlessRenderer,
format: crate::metal::enums::NSUInteger,
size: (u32, u32),
msaa: u32,
frame: Vec<u8>,
pending: Option<Vec<u8>>,
ssao: Option<(f32, f32)>,
grain: f32,
grain_seed: f32,
confirmed: bool,
unconfirmed: u32,
post: Option<crate::metal::MetalPostFx>,
screen: Option<crate::postprocessing::Target>,
marks: Option<crate::marks::gpu::Gpu>,
stale: std::sync::atomic::AtomicBool,
}
impl MetalPath {
pub(super) fn new(color_format: wgpu::TextureFormat, width: u32, height: u32) -> Option<Self> {
let format = match color_format {
wgpu::TextureFormat::Rgba8UnormSrgb | wgpu::TextureFormat::Rgba8Unorm => {
pixel_format::RGBA8_UNORM_SRGB
}
wgpu::TextureFormat::Bgra8UnormSrgb | wgpu::TextureFormat::Bgra8Unorm => {
pixel_format::BGRA8_UNORM_SRGB
}
wgpu::TextureFormat::Rgba16Float => pixel_format::RGBA16_FLOAT,
other => {
warn_fallback(&format!("the {other:?} target format"));
return None;
}
};
let mut hr = build(format, width, height, 1)?;
hr.renderer().set_keep_attachments(true);
hr.renderer().set_encoded_output(matches!(
color_format,
wgpu::TextureFormat::Rgba8Unorm | wgpu::TextureFormat::Bgra8Unorm
));
static SAID: std::sync::Once = std::sync::Once::new();
SAID.call_once(|| {
eprintln!(
"threers: THREERS_BACKEND=metal: drawing on the native Metal backend ({})",
hr.device().name()
)
});
Some(Self {
hr,
format,
size: (width, height),
msaa: 1,
frame: Vec::new(),
pending: None,
ssao: None,
grain: 0.0,
grain_seed: 0.0,
confirmed: false,
unconfirmed: 0,
post: None,
screen: None,
marks: None,
stale: std::sync::atomic::AtomicBool::new(false),
})
}
pub(super) fn set_msaa(&mut self, samples: u32) -> bool {
let samples = if samples <= 1 { 1 } else { 4 };
if samples == self.msaa {
return true;
}
match build(self.format, self.size.0, self.size.1, samples) {
Some(mut hr) => {
hr.renderer().set_keep_attachments(true);
self.hr = hr;
self.msaa = samples;
true
}
None => false,
}
}
pub(super) fn set_bloom(&mut self, strength: f32, threshold: f32, radius: f32) {
self.hr.set_bloom(strength, threshold, radius);
}
pub(super) fn set_ssao(&mut self, strength: f32, radius: f32) {
self.ssao = Some((strength, radius));
}
pub(super) fn set_film_grade(&mut self, vignette: f32, grain: f32) {
self.grain = grain;
self.hr.set_film_grade(vignette, grain);
}
fn follow(&mut self, wgpu: &super::Renderer) {
let m = self.hr.renderer();
let (mode, exposure) = wgpu.tone_mapping();
m.set_tone_mapping(mode, exposure);
m.set_pixel_ratio(wgpu.pixel_ratio());
match wgpu.viewport() {
Some(r) => m.set_viewport(r.x, r.y, r.width, r.height),
None => m.reset_viewport(),
}
match wgpu.scissor() {
Some(r) => m.set_scissor(r.x, r.y, r.width, r.height),
None => m.reset_scissor(),
}
m.set_scissor_test(wgpu.scissor_test());
m.set_auto_clear(wgpu.auto_clear());
}
pub(super) fn render(
&mut self,
scene: &mut Scene,
camera: &dyn Camera,
wgpu: &super::Renderer,
) -> Result<(), String> {
self.follow(wgpu);
if let Some((strength, radius)) = self.ssao {
self.hr.set_ssao(Some(ssao_for(camera, strength, radius)));
}
if self.grain > 0.0 {
self.grain_seed += 1.0;
self.hr.set_grain_seed(self.grain_seed);
}
self.hr.render_queued(scene, camera).map_err(|e| e.to_string())?;
self.stale.store(false, std::sync::atomic::Ordering::Relaxed);
if !self.confirmed {
self.unconfirmed += 1;
if self.unconfirmed == UNCONFIRMED_NOTE {
static SAID: std::sync::Once = std::sync::Once::new();
SAID.call_once(|| {
eprintln!(
"threers: THREERS_BACKEND=metal: {UNCONFIRMED_NOTE} frames drawn and none read back; \
wgpu draws each one as well until a frame is read from Metal"
)
});
}
}
Ok(())
}
pub(super) fn clear(
&mut self,
color: crate::math::Color,
alpha: f32,
wgpu: &super::Renderer,
) -> Result<(), String> {
self.follow(wgpu);
self.hr.discard_queued();
self.hr.clear(color, alpha).map_err(|e| e.to_string())?;
self.frame = self.hr.read_rgba().map_err(|e| e.to_string())?;
self.stale.store(false, std::sync::atomic::Ordering::Relaxed);
Ok(())
}
pub(super) fn upload_geometry(&mut self, geometry: &Arc<crate::core::BufferGeometry>) {
if let Err(e) = self.hr.renderer().upload_geometry(geometry) {
log::warn!("metal: geometry upload failed: {e}");
}
}
pub(super) fn vertex_buffer(&mut self, geometry: &Arc<crate::core::BufferGeometry>) -> Option<crate::marks::gpu::Buffer> {
let (id, size) = self.hr.renderer().vertex_buffer(geometry)?;
Some(unsafe { crate::marks::gpu::Buffer::from_metal(id, size as u64) })
}
pub(super) fn marks_gpu(&mut self) -> crate::marks::gpu::Gpu {
let device = self.hr.device();
self.marks.get_or_insert_with(|| crate::marks::gpu::Gpu::from(device)).clone()
}
pub(super) fn mark_target(&self) -> crate::marks::MarkTarget<'static> {
self.drawn_over();
unsafe { crate::marks::MarkTarget::from_metal_pass(&self.hr.target().attachments()) }
}
pub(super) fn drawn_over(&self) {
self.stale.store(true, std::sync::atomic::Ordering::Relaxed);
}
fn fresh(&mut self) {
if self.stale.swap(false, std::sync::atomic::Ordering::Relaxed) {
self.hr.discard_queued();
match self.hr.read_rgba() {
Ok(f) => self.frame = f,
Err(e) => log::warn!("THREERS_BACKEND=metal: reading the frame back after marks failed: {e}"),
}
} else if let Err(e) = self.hr.finish_queued_into(&mut self.frame) {
log::warn!("THREERS_BACKEND=metal: reading the frame back failed: {e}");
}
}
pub(super) fn wait_idle(&self) {
if let Err(e) = self.hr.wait_queued() {
log::warn!("THREERS_BACKEND=metal: waiting for the frame failed: {e}");
}
}
pub(super) fn compose(
&mut self,
composer: &mut crate::postprocessing::EffectComposer,
scene: &mut Scene,
camera: &dyn Camera,
wgpu: &super::Renderer,
) -> Result<Vec<u8>, String> {
self.follow(wgpu);
if self.post.is_none() {
let mut post = crate::metal::MetalPostFx::new(self.hr.device()).map_err(|e| e.to_string())?;
post.prepare().map_err(|e| e.to_string())?;
self.post = Some(post);
}
let post = self.post.as_mut().expect("just made");
let (w, h) = composer.drawing_size();
let mut backend = post.backend(self.hr.renderer());
let screen = crate::postprocessing::ensure_target(&mut self.screen, &mut backend, w, h, composer.screen_format());
composer.render_to_target(&mut backend, scene, camera, screen.clone());
self.confirmed = true;
post.read_rgba(screen.id()).map_err(|e| e.to_string())
}
pub(super) fn frame(&mut self) -> Vec<u8> {
self.fresh();
self.confirmed = true;
self.frame.clone()
}
#[cfg(feature = "captions")]
pub(super) fn blend_overlay(&mut self, rgba: &[u8]) {
self.fresh();
let lut = srgb_to_linear_lut();
for (dst, src) in self
.frame
.as_chunks_mut::<4>()
.0
.iter_mut()
.zip(rgba.as_chunks::<4>().0)
{
let a = src[3] as f32 / 255.0;
if a <= 0.0 {
continue;
}
for c in 0..3 {
let v = lut[src[c] as usize] * a + lut[dst[c] as usize] * (1.0 - a);
dst[c] = linear_to_srgb_byte(v);
}
let da = dst[3] as f32 / 255.0;
dst[3] = ((a + da * (1.0 - a)) * 255.0 + 0.5) as u8;
}
}
pub(super) fn confirmed(&self) -> bool {
self.confirmed
}
pub(super) fn pipelined(&mut self, frame: Vec<u8>) -> Option<Vec<u8>> {
self.pending.replace(frame)
}
pub(super) fn finish(&mut self) -> Option<Vec<u8>> {
self.pending.take()
}
}
fn build(format: crate::metal::enums::NSUInteger, width: u32, height: u32, msaa: u32) -> Option<MetalHeadlessRenderer> {
match MetalHeadlessRenderer::builder()
.size(width, height)
.msaa(msaa)
.color_format(format)
.build()
{
Ok(hr) => Some(hr),
Err(e) => {
warn_fallback(&format!("this machine ({e})"));
None
}
}
}
fn ssao_for(camera: &dyn Camera, strength: f32, radius: f32) -> SsaoSettings {
let p = camera.projection_matrix().elements;
let (near, far) = camera.near_far();
let (tan_half_fov, aspect) = if p[5] != 0.0 && p[0] != 0.0 {
(1.0 / p[5], p[5] / p[0])
} else {
(1.0, 1.0)
};
SsaoSettings { strength, radius, near, far, tan_half_fov, aspect }
}
#[cfg(feature = "captions")]
fn srgb_to_linear_lut() -> &'static [f32; 256] {
static LUT: std::sync::OnceLock<[f32; 256]> = std::sync::OnceLock::new();
LUT.get_or_init(|| {
std::array::from_fn(|i| {
let s = i as f32 / 255.0;
if s <= 0.040_45 {
s / 12.92
} else {
((s + 0.055) / 1.055).powf(2.4)
}
})
})
}
#[cfg(feature = "captions")]
fn linear_to_srgb_byte(v: f32) -> u8 {
let v = v.clamp(0.0, 1.0);
let s = if v <= 0.003_130_8 { v * 12.92 } else { 1.055 * v.powf(1.0 / 2.4) - 0.055 };
(s * 255.0 + 0.5) as u8
}