//! GPU path tracing for Rendering mode: the CPU tracer in [`crate::trace`] (the oracle) ported to //! compute shaders (`shaders/trace.wgsl`, `shaders/trace_post.wgsl`), same light transport and //! the same random streams, so both converge to the same image. //! //! The mesh, its BVH and the environment's importance-sampling tables live in storage buffers; //! materials are copies of the renderer's display textures (`compose::display` packing, one array //! layer per texture set plus one for the default material). [`GpuTracer::pass`] adds samples per //! pixel to float accumulation buffers; [`GpuTracer::resolve`] runs the à-trous denoiser and tone //! maps into an RGBA8 texture, so the app shows renders without reading them back. use std::future::Future; use std::sync::Arc; use std::task::{Context, Poll, Waker}; use bytemuck::{Pod, Zeroable}; use texturecraft_compose::DisplayKind; use texturecraft_geom::glam::{Vec3, Vec4}; use texturecraft_geom::{Mesh, OrbitCamera}; use wgpu::util::DeviceExt; use crate::Renderer; use crate::ibl::EnvImage; use crate::trace::{TraceDisplay, TraceScene, TraceSettings}; /// Texture sets the tracer takes (one more array layer holds the default material). pub const MAX_SETS: usize = 255; /// Depth of the shader's BVH traversal stack (`STACK` in trace.wgsl). pub(crate) const STACK: usize = 64; const KINDS: usize = DisplayKind::ALL.len(); /// Bytes of the trace uniform: [`Head`] then 256 texture-set entries (`MAX_SETS` in trace.wgsl). const PARAMS_SIZE: u64 = (size_of::() + 256 * 16) as u64; /// Post uniform slots: resolve and denoise init, then the five à-trous steps. const STEPS: [u32; 6] = [0, 1, 2, 4, 8, 16]; const WORKGROUP: u32 = 8; #[repr(C)] #[derive(Clone, Copy, Pod, Zeroable)] struct Head { inv_vp: [f32; 16], forward: [f32; 4], size: [u32; 4], cfg: [u32; 4], env: [f32; 4], sigma: [f32; 4], eye: [f32; 4], lens: [f32; 4], } #[repr(C)] #[derive(Clone, Copy, Pod, Zeroable)] struct PostRaw { size: [u32; 4], display: [f32; 4], } struct Geometry { mesh: Arc, tri_set: Arc>, nodes: wgpu::Buffer, tris: wgpu::Buffer, verts: wgpu::Buffer, } struct EnvGpu { image: Arc, view: wgpu::TextureView, cdf: wgpu::Buffer, /// Whether `cdf` holds importance-sampling tables. light: bool, } /// Copies of the renderer's display textures, one array per [`DisplayKind`]. struct Materials { rev: u64, arrays: Vec<(wgpu::Texture, wgpu::TextureView)>, /// Per layer: width, height, mask of kinds that are 1×1 placeholders. info: Vec<[f32; 3]>, } struct Accum { width: u32, height: u32, /// Radiance + luminance², albedo + hits, normal + depth, environment of misses. acc: [wgpu::Buffer; 4], /// Ping-pong demodulated radiance + variance for the denoiser. illum: [wgpu::Buffer; 2], } /// Scene constants of the trace uniform. struct SceneConst { spec_gloss: bool, eps: f32, sigma: Vec3, rotation: f32, heights: Vec, ior: f32, /// Focus depth (0: the orbit target) and lens radius in world units (0: pinhole). lens: [f32; 2], } /// The GPU path tracer: pipelines, the uploaded scene and one view's accumulation. pub struct GpuTracer { trace_bgl: wgpu::BindGroupLayout, post_bgl: wgpu::BindGroupLayout, trace_pipe: wgpu::ComputePipeline, init_pipe: wgpu::ComputePipeline, step_pipe: wgpu::ComputePipeline, resolve_pipe: wgpu::ComputePipeline, params: wgpu::Buffer, post: wgpu::Buffer, post_stride: u32, geometry: Option, env: Option, materials: Option, acc: Option, /// Keep the preceding size so motion/full-resolution switches can reuse allocations. spare_acc: Option, /// How many sets of accumulation buffers were allocated (for tests). #[cfg(test)] acc_allocations: u32, scene: Option, bind: Option, samples: u32, } /// The error a scope caught, if wgpu reported it at once (native backends do). fn caught(f: impl Future>) -> Option { let mut f = std::pin::pin!(f); match f.as_mut().poll(&mut Context::from_waker(Waker::noop())) { Poll::Ready(e) => e, Poll::Pending => None, } } /// Run `f` with validation and out-of-memory errors turned into an `Err` instead of wgpu's /// default handler (which panics). pub(crate) fn scoped(device: &wgpu::Device, what: &str, f: impl FnOnce() -> T) -> Result { let oom = device.push_error_scope(wgpu::ErrorFilter::OutOfMemory); let invalid = device.push_error_scope(wgpu::ErrorFilter::Validation); let out = f(); let errors = [caught(invalid.pop()), caught(oom.pop())]; match errors.into_iter().flatten().next() { Some(e) => Err(format!("{what}: {e}")), None => Ok(out), } } /// What [`checked`] knows right after the call. pub(crate) enum Checked { /// wgpu answered at once (native backends, WebGL): the value, or what went wrong. Done(Result), /// The browser's WebGPU answers later: the value, possibly invalid, and where the answer /// arrives (`None` for success). Don't use the value until it arrives. (Native backends /// never answer late; the renderer's tests build this variant by hand.) #[cfg_attr(not(target_arch = "wasm32"), allow(dead_code))] Later(T, std::sync::mpsc::Receiver>), } /// [`scoped`] for work whose errors may arrive later: never takes an unanswered scope as success. pub(crate) fn checked(device: &wgpu::Device, what: &str, f: impl FnOnce() -> T) -> Checked { let oom = device.push_error_scope(wgpu::ErrorFilter::OutOfMemory); let invalid = device.push_error_scope(wgpu::ErrorFilter::Validation); let out = f(); let (invalid, oom) = (invalid.pop(), oom.pop()); let what = what.to_string(); let mut answer = Box::pin(async move { let invalid = invalid.await; let oom = oom.await; // An allocation that ran out of memory also makes later calls on it invalid: the // out-of-memory error is the cause. oom.or(invalid).map(|e| format!("{what}: {e}")) }); #[cfg(not(target_arch = "wasm32"))] { Checked::Done(match pollster::block_on(answer.as_mut()) { Some(e) => Err(e), None => Ok(out), }) } #[cfg(target_arch = "wasm32")] { match answer.as_mut().poll(&mut Context::from_waker(Waker::noop())) { Poll::Ready(Some(e)) => Checked::Done(Err(e)), Poll::Ready(None) => Checked::Done(Ok(out)), Poll::Pending => { let (tx, rx) = std::sync::mpsc::channel(); wasm_bindgen_futures::spawn_local(async move { let _ = tx.send(answer.await); }); Checked::Later(out, rx) } } } } pub(crate) fn entry(binding: u32, ty: wgpu::BindingType) -> wgpu::BindGroupLayoutEntry { wgpu::BindGroupLayoutEntry { binding, visibility: wgpu::ShaderStages::COMPUTE, ty, count: None } } pub(crate) fn storage(binding: u32, read_only: bool) -> wgpu::BindGroupLayoutEntry { entry(binding, wgpu::BindingType::Buffer { ty: wgpu::BufferBindingType::Storage { read_only }, has_dynamic_offset: false, min_binding_size: None }) } fn texture(binding: u32, view_dimension: wgpu::TextureViewDimension) -> wgpu::BindGroupLayoutEntry { entry(binding, wgpu::BindingType::Texture { sample_type: wgpu::TextureSampleType::Float { filterable: false }, view_dimension, multisampled: false }) } pub(crate) fn buffer(device: &wgpu::Device, label: &str, contents: &[u8]) -> wgpu::Buffer { device.create_buffer_init(&wgpu::util::BufferInitDescriptor { label: Some(label), contents, usage: wgpu::BufferUsages::STORAGE }) } fn bits(v: Vec3, w: u32) -> [u32; 4] { [v.x.to_bits(), v.y.to_bits(), v.z.to_bits(), w] } /// Depth of the deepest leaf (the root is 1), or None for a malformed tree. pub(crate) fn bvh_depth(nodes: &[(Vec3, Vec3, u32, u32)]) -> Option { let mut stack = vec![(0usize, 1usize)]; let mut deepest = 0; let mut visited = 0usize; while let Some((i, d)) = stack.pop() { visited += 1; let &(_, _, first, count) = nodes.get(i)?; deepest = deepest.max(d); if count == 0 && visited <= nodes.len() { stack.push((first as usize, d + 1)); stack.push((first as usize + 1, d + 1)); } } (visited <= nodes.len()).then_some(deepest) } impl GpuTracer { /// Whether `device` can run the tracer (compute shaders and enough bindings: not WebGL2). pub fn supported(device: &wgpu::Device) -> bool { let l = device.limits(); l.max_storage_buffers_per_shader_stage >= 8 && l.max_storage_textures_per_shader_stage >= 1 && l.max_sampled_textures_per_shader_stage > KINDS as u32 && l.max_compute_invocations_per_workgroup >= WORKGROUP * WORKGROUP && l.max_compute_workgroup_size_x >= WORKGROUP && l.max_compute_workgroup_size_y >= WORKGROUP && l.max_uniform_buffer_binding_size >= PARAMS_SIZE && l.max_texture_array_layers >= 2 } pub fn new(device: &wgpu::Device) -> Result { if !Self::supported(device) { return Err("GPU path tracing needs compute shaders (WebGPU, Vulkan, Metal or DirectX 12)".into()); } scoped(device, "GPU path tracing: pipelines", || Self::create(device)) } fn create(device: &wgpu::Device) -> GpuTracer { let uniform = |binding, dynamic| { entry(binding, wgpu::BindingType::Buffer { ty: wgpu::BufferBindingType::Uniform, has_dynamic_offset: dynamic, min_binding_size: None }) }; let mut trace_entries = vec![uniform(0, false), storage(1, true), storage(2, true), storage(3, true), storage(4, true)]; trace_entries.extend((5..9).map(|b| storage(b, false))); trace_entries.push(texture(9, wgpu::TextureViewDimension::D2)); trace_entries.extend((10..10 + KINDS as u32).map(|b| texture(b, wgpu::TextureViewDimension::D2Array))); let trace_bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { label: Some("tc_trace"), entries: &trace_entries }); let mut post_entries = vec![uniform(0, true)]; post_entries.extend((1..6).map(|b| storage(b, true))); post_entries.push(storage(6, false)); post_entries.push(entry( 7, wgpu::BindingType::StorageTexture { access: wgpu::StorageTextureAccess::WriteOnly, format: wgpu::TextureFormat::Rgba8Unorm, view_dimension: wgpu::TextureViewDimension::D2, }, )); let post_bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { label: Some("tc_trace_post"), entries: &post_entries }); let module = |label, src: &str| device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some(label), source: wgpu::ShaderSource::Wgsl(src.into()) }); let trace_module = module("tc_trace", concat!(include_str!("shaders/rays.wgsl"), include_str!("shaders/trace.wgsl"))); let post_module = module("tc_trace_post", include_str!("shaders/trace_post.wgsl")); let pipe = |bgl: &wgpu::BindGroupLayout, m: &wgpu::ShaderModule, entry_point: &str| { let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some(entry_point), bind_group_layouts: &[Some(bgl)], immediate_size: 0, }); device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { label: Some(entry_point), layout: Some(&layout), module: m, entry_point: Some(entry_point), compilation_options: Default::default(), cache: None, }) }; let post_stride = (size_of::() as u32).next_multiple_of(device.limits().min_uniform_buffer_offset_alignment.max(1)); let uniform_buffer = |label, size| { device.create_buffer(&wgpu::BufferDescriptor { label: Some(label), size, usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, mapped_at_creation: false, }) }; GpuTracer { trace_pipe: pipe(&trace_bgl, &trace_module, "trace_main"), init_pipe: pipe(&post_bgl, &post_module, "denoise_init"), step_pipe: pipe(&post_bgl, &post_module, "denoise_step"), resolve_pipe: pipe(&post_bgl, &post_module, "resolve"), trace_bgl, post_bgl, params: uniform_buffer("tc_trace_params", PARAMS_SIZE), post: uniform_buffer("tc_trace_post", u64::from(post_stride) * STEPS.len() as u64), post_stride, geometry: None, env: None, materials: None, acc: None, spare_acc: None, #[cfg(test)] acc_allocations: 0, scene: None, bind: None, samples: 0, } } /// Samples per pixel accumulated since the last [`GpuTracer::reset`]. pub fn samples(&self) -> u32 { self.samples } /// Free the scene and accumulation memory, keeping the compiled pipelines. pub fn release(&mut self) { (self.geometry, self.env, self.materials, self.acc, self.scene, self.bind) = (None, None, None, None, None, None); self.spare_acc = None; self.samples = 0; } /// Upload what changed of `scene`: the mesh and BVH (when the mesh or its texture-set /// mapping changed), the environment and the shading constants. pub fn set_scene(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, scene: &TraceScene) -> Result<(), String> { let limits = device.limits(); let max_buf = limits.max_storage_buffer_binding_size.min(limits.max_buffer_size); let fits = |what: &str, bytes: usize| { if bytes as u64 <= max_buf { Ok(()) } else { Err(format!("the {what} ({} MB) exceeds this GPU's buffer limit", bytes >> 20)) } }; let same_geometry = self.geometry.as_ref().is_some_and(|g| Arc::ptr_eq(&g.mesh, &scene.mesh) && g.tri_set == scene.tri_set); if !same_geometry { let nodes: Vec<(Vec3, Vec3, u32, u32)> = scene.bvh.nodes().collect(); if bvh_depth(&nodes).is_none_or(|d| d >= STACK) { return Err("the mesh's BVH is too deep for GPU traversal".into()); } let (data, verts) = geometry_data(&scene.mesh, &scene.bvh, &scene.tri_set); let (nodes, tris) = data; for (what, b) in [("BVH", nodes.len()), ("triangle list", tris.len()), ("vertex list", verts.len())] { fits(what, b * 16)?; } self.geometry = Some(scoped(device, "GPU path tracing: mesh upload", || Geometry { mesh: scene.mesh.clone(), tri_set: scene.tri_set.clone(), nodes: buffer(device, "tc_trace_nodes", bytemuck::cast_slice(&nodes)), tris: buffer(device, "tc_trace_tris", bytemuck::cast_slice(&tris)), verts: buffer(device, "tc_trace_verts", bytemuck::cast_slice(&verts)), })?); self.bind = None; } if !self.env.as_ref().is_some_and(|e| Arc::ptr_eq(&e.image, &scene.env)) { let img = &scene.env; let (w, h) = (img.width as usize, img.height as usize); let valid = w > 0 && h > 0 && img.data.len() >= w * h && img.width.max(img.height) <= limits.max_texture_dimension_2d; let (tw, th, rgba): (u32, u32, Vec<[f32; 4]>) = if valid { (img.width, img.height, img.data.iter().take(w * h).map(|c| [c[0], c[1], c[2], 1.0]).collect()) } else { (1, 1, vec![[0.0; 4]]) }; let mut cdf = Vec::new(); if let Some(l) = scene.light.as_ref().filter(|l| valid && l.width == w && l.height == h) { cdf.extend_from_slice(&l.rows); cdf.extend_from_slice(&l.cols); cdf.extend_from_slice(&l.prob); } fits("environment table", cdf.len() * 4)?; let light = !cdf.is_empty(); if !light { cdf.push(0.0); } let env = scoped(device, "GPU path tracing: environment upload", || { let tex = device.create_texture_with_data( queue, &wgpu::TextureDescriptor { label: Some("tc_trace_env"), size: wgpu::Extent3d { width: tw, height: th, depth_or_array_layers: 1 }, mip_level_count: 1, sample_count: 1, dimension: wgpu::TextureDimension::D2, format: wgpu::TextureFormat::Rgba32Float, usage: wgpu::TextureUsages::TEXTURE_BINDING, view_formats: &[], }, wgpu::util::TextureDataOrder::LayerMajor, bytemuck::cast_slice(&rgba), ); EnvGpu { image: scene.env.clone(), view: tex.create_view(&Default::default()), cdf: buffer(device, "tc_trace_cdf", bytemuck::cast_slice(&cdf)), light, } })?; self.env = Some(env); self.bind = None; } self.scene = Some(SceneConst { spec_gloss: scene.spec_gloss, eps: scene.eps, sigma: scene.scatter_sigma, rotation: scene.env_rotation, heights: scene.sets.iter().map(|s| s.height_strength).collect(), ior: scene.ior, lens: scene.lens.map_or([0.0; 2], |[focus, aperture]| [focus, aperture.max(0.0) * scene.radius]), }); Ok(()) } /// Copy the renderer's display textures when their content changed (a GPU-side copy); /// true when it did (samples taken before no longer match the scene). pub fn sync_materials( &mut self, device: &wgpu::Device, queue: &wgpu::Queue, encoder: &mut wgpu::CommandEncoder, renderer: &Renderer, ) -> Result { let rev = renderer.content_rev(); if self.materials.as_ref().is_some_and(|m| m.rev == rev) { return Ok(false); } let sets = renderer.display_textures(); if sets.len() > MAX_SETS || sets.iter().any(|s| s.len() != KINDS) { return Err(format!("GPU path tracing takes at most {MAX_SETS} texture sets")); } let layers = sets.len() as u32 + 1; let limits = device.limits(); if layers > limits.max_texture_array_layers { return Err(format!("this GPU takes at most {} texture sets", limits.max_texture_array_layers.saturating_sub(1))); } let old = self.materials.take(); let mut arrays = Vec::with_capacity(KINDS); for (k, kind) in DisplayKind::ALL.into_iter().enumerate() { let size = sets.iter().filter_map(|s| s.get(k)).fold((1, 1), |(w, h), t| (t.width().max(w), t.height().max(h))); let reuse = old.as_ref().and_then(|m| m.arrays.get(k)).filter(|(t, _)| (t.width(), t.height(), t.depth_or_array_layers()) == (size.0, size.1, layers)); let (tex, view) = match reuse { Some(a) => a.clone(), None => scoped(device, "GPU path tracing: material textures", || { let tex = device.create_texture(&wgpu::TextureDescriptor { label: Some("tc_trace_material"), size: wgpu::Extent3d { width: size.0, height: size.1, depth_or_array_layers: layers }, mip_level_count: 1, sample_count: 1, dimension: wgpu::TextureDimension::D2, format: crate::renderer::display_format(kind), usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, view_formats: &[], }); let view = tex.create_view(&wgpu::TextureViewDescriptor { dimension: Some(wgpu::TextureViewDimension::D2Array), ..Default::default() }); (tex, view) })?, }; if reuse.is_none() { self.bind = None; } for (layer, src) in sets.iter().filter_map(|s| s.get(k)).enumerate() { encoder.copy_texture_to_texture( src.as_image_copy(), wgpu::TexelCopyTextureInfo { texture: &tex, mip_level: 0, origin: wgpu::Origin3d { x: 0, y: 0, z: layer as u32 }, aspect: wgpu::TextureAspect::All, }, wgpu::Extent3d { width: src.width(), height: src.height(), depth_or_array_layers: 1 }, ); } // The default material: one texel of the kind's neutral value. let texel = kind.default_texel(); queue.write_texture( wgpu::TexelCopyTextureInfo { texture: &tex, mip_level: 0, origin: wgpu::Origin3d { x: 0, y: 0, z: layers - 1 }, aspect: wgpu::TextureAspect::All, }, &texel, wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(texel.len() as u32), rows_per_image: Some(1) }, wgpu::Extent3d { width: 1, height: 1, depth_or_array_layers: 1 }, ); arrays.push((tex, view)); } let mut info: Vec<[f32; 3]> = sets .iter() .map(|s| { // The set's size is its largest texture's; any kind may still be a 1×1 placeholder. let dims = s.iter().fold((1, 1), |(w, h), t| (t.width().max(w), t.height().max(h))); let small = s.iter().enumerate().filter(|(_, t)| (t.width(), t.height()) != dims).fold(0u32, |m, (k, _)| m | 1 << k); [dims.0 as f32, dims.1 as f32, small as f32] }) .collect(); info.push([1.0, 1.0, 0.0]); self.materials = Some(Materials { rev, arrays, info }); Ok(true) } /// Start over at `width × height`, keeping the active render intact if allocation fails. pub fn reset(&mut self, device: &wgpu::Device, encoder: &mut wgpu::CommandEncoder, width: u32, height: u32) -> Result<(), String> { let (width, height) = (width.clamp(1, 8192), height.clamp(1, 8192)); let bytes = u64::from(width) * u64::from(height) * 16; let limits = device.limits(); // Reject unsupported sizes before invalidating the displayed render if bytes > limits.max_storage_buffer_binding_size.min(limits.max_buffer_size) { return Err(format!("a {width}×{height} render exceeds this GPU's buffer limit")); } if let Some(accumulation) = self.acc.as_ref().filter(|accumulation| (accumulation.width, accumulation.height) == (width, height)) { for buffer in &accumulation.acc { encoder.clear_buffer(buffer, 0, None); } self.samples = 0; return Ok(()); } // Reused buffers must not retain samples from the previous view if let Some(spare) = self.spare_acc.take_if(|accumulation| (accumulation.width, accumulation.height) == (width, height)) { for buffer in spare.acc.iter().chain(&spare.illum) { encoder.clear_buffer(buffer, 0, None); } self.spare_acc = self.acc.replace(spare); self.bind = None; self.samples = 0; return Ok(()); } // Retire the obsolete spare before allocating, but keep the active render until success self.spare_acc = None; let create_buffer = |label| { device.create_buffer(&wgpu::BufferDescriptor { label: Some(label), size: bytes, usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::COPY_SRC, mapped_at_creation: false, }) }; let accumulation = scoped(device, "GPU path tracing: accumulation buffers", || Accum { width, height, acc: ["tc_acc_hit", "tc_acc_albedo", "tc_acc_normal", "tc_acc_env"].map(create_buffer), illum: ["tc_illum_a", "tc_illum_b"].map(create_buffer), })?; self.spare_acc = self.acc.replace(accumulation); self.bind = None; self.samples = 0; #[cfg(test)] { self.acc_allocations += 1; } Ok(()) } /// Add `spp` samples per pixel (call once per submission: the uniform is rewritten). False /// until a scene, materials and a size are set. pub fn pass( &mut self, device: &wgpu::Device, queue: &wgpu::Queue, encoder: &mut wgpu::CommandEncoder, cam: &OrbitCamera, settings: &TraceSettings, spp: u32, ) -> bool { let (Some(acc), Some(geo), Some(env), Some(mat), Some(sc)) = (&self.acc, &self.geometry, &self.env, &self.materials, &self.scene) else { return false }; let bind = self.bind.get_or_insert_with(|| { let mut entries = vec![ wgpu::BindGroupEntry { binding: 0, resource: self.params.as_entire_binding() }, wgpu::BindGroupEntry { binding: 1, resource: geo.nodes.as_entire_binding() }, wgpu::BindGroupEntry { binding: 2, resource: geo.tris.as_entire_binding() }, wgpu::BindGroupEntry { binding: 3, resource: geo.verts.as_entire_binding() }, wgpu::BindGroupEntry { binding: 4, resource: env.cdf.as_entire_binding() }, ]; entries.extend(acc.acc.iter().zip(5..).map(|(b, binding)| wgpu::BindGroupEntry { binding, resource: b.as_entire_binding() })); entries.push(wgpu::BindGroupEntry { binding: 9, resource: wgpu::BindingResource::TextureView(&env.view) }); entries .extend(mat.arrays.iter().zip(10..).map(|((_, v), binding)| wgpu::BindGroupEntry { binding, resource: wgpu::BindingResource::TextureView(v) })); device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("tc_trace"), layout: &self.trace_bgl, entries: &entries }) }); let (w, h) = (acc.width, acc.height); let inv_vp = cam.view_proj(w as f32 / h as f32).inverse(); let (sin, cos) = sc.rotation.sin_cos(); let head = Head { inv_vp: inv_vp.to_cols_array(), forward: cam.forward().extend(sc.eps).to_array(), size: [w, h, self.samples, spp.max(1)], cfg: [settings.bounces, u32::from(sc.spec_gloss), u32::from(env.light), (mat.info.len() - 1) as u32], env: [sin, cos, 0.0, 0.0], sigma: sc.sigma.extend(0.0).to_array(), eye: cam.eye().extend(1.0).to_array(), lens: [if sc.lens[0] > 0.0 { sc.lens[0] } else { cam.distance }, sc.lens[1], sc.ior, 0.0], }; let mut sets = [[0.0f32; 4]; 256]; for (i, (slot, m)) in sets.iter_mut().zip(&mat.info).enumerate() { *slot = [m[0], m[1], m[2], sc.heights.get(i).copied().unwrap_or(0.0)]; } let mut bytes = bytemuck::bytes_of(&head).to_vec(); bytes.extend_from_slice(bytemuck::cast_slice(&sets)); queue.write_buffer(&self.params, 0, &bytes); let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { label: Some("tc_trace"), timestamp_writes: None }); cpass.set_pipeline(&self.trace_pipe); cpass.set_bind_group(0, &*bind, &[]); cpass.dispatch_workgroups(w.div_ceil(WORKGROUP), h.div_ceil(WORKGROUP), 1); drop(cpass); self.samples = self.samples.saturating_add(spp.max(1)); true } /// Display pixels into `out` (an [`GpuTracer::output_texture`] of the render's size): /// denoised when `display.denoise`, tone mapped over the backdrop as [`crate::trace::Tracer::rgba8`]. pub fn resolve( &self, device: &wgpu::Device, queue: &wgpu::Queue, encoder: &mut wgpu::CommandEncoder, display: &TraceDisplay, out: &wgpu::TextureView, ) -> bool { let Some(acc) = &self.acc else { return false }; let flag = |b: bool| if b { 1.0 } else { 0.0 }; let disp = [display.exposure, flag(display.aces), display.env_opacity, flag(display.denoise)]; let mut bytes = vec![0u8; self.post_stride as usize * STEPS.len()]; for (i, step) in STEPS.iter().enumerate() { let raw = PostRaw { size: [acc.width, acc.height, self.samples, *step], display: disp }; if let Some(slot) = bytes.get_mut(i * self.post_stride as usize..).and_then(|s| s.get_mut(..size_of::())) { slot.copy_from_slice(bytemuck::bytes_of(&raw)); } } queue.write_buffer(&self.post, 0, &bytes); let post = wgpu::BufferBinding { buffer: &self.post, offset: 0, size: wgpu::BufferSize::new(size_of::() as u64) }; // a: illum[0] → illum[1], b: illum[1] → illum[0]. let group = |src: &wgpu::Buffer, dst: &wgpu::Buffer| { let mut entries = vec![wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::Buffer(post.clone()) }]; entries.extend(acc.acc.iter().zip(1..).map(|(b, binding)| wgpu::BindGroupEntry { binding, resource: b.as_entire_binding() })); entries.push(wgpu::BindGroupEntry { binding: 5, resource: src.as_entire_binding() }); entries.push(wgpu::BindGroupEntry { binding: 6, resource: dst.as_entire_binding() }); entries.push(wgpu::BindGroupEntry { binding: 7, resource: wgpu::BindingResource::TextureView(out) }); device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("tc_trace_post"), layout: &self.post_bgl, entries: &entries }) }; let [i0, i1] = &acc.illum; let (a, b) = (group(i0, i1), group(i1, i0)); let groups = (acc.width.div_ceil(WORKGROUP), acc.height.div_ceil(WORKGROUP)); let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { label: Some("tc_trace_post"), timestamp_writes: None }); let mut run = |pipe: &wgpu::ComputePipeline, bg: &wgpu::BindGroup, slot: usize| { cpass.set_pipeline(pipe); cpass.set_bind_group(0, bg, &[slot as u32 * self.post_stride]); cpass.dispatch_workgroups(groups.0, groups.1, 1); }; if display.denoise { // The five steps alternate b, a, b, a, b, leaving the result in illum[0]. run(&self.init_pipe, &a, 0); for slot in 1..STEPS.len() { run(&self.step_pipe, if slot % 2 == 1 { &b } else { &a }, slot); } } run(&self.resolve_pipe, &a, 0); true } /// The texture [`GpuTracer::resolve`] writes (RGBA8, sRGB-encoded values, as the CPU tracer's /// `rgba8`): also sampled by the UI and copied for read-back. pub fn output_texture(device: &wgpu::Device, width: u32, height: u32) -> wgpu::Texture { device.create_texture(&wgpu::TextureDescriptor { label: Some("tc_trace_out"), size: wgpu::Extent3d { width: width.clamp(1, 8192), height: height.clamp(1, 8192), depth_or_array_layers: 1 }, mip_level_count: 1, sample_count: 1, dimension: wgpu::TextureDimension::D2, format: wgpu::TextureFormat::Rgba8Unorm, usage: wgpu::TextureUsages::STORAGE_BINDING | wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_SRC, view_formats: &[], }) } /// A whole render, blocking: `samples` passes at `size`, resolved and read back as RGBA8 /// (sRGB) pixels. `renderer` holds the session's texture sets. #[allow(clippy::too_many_arguments)] pub fn render( &mut self, device: &wgpu::Device, queue: &wgpu::Queue, renderer: &Renderer, scene: &TraceScene, cam: &OrbitCamera, settings: &TraceSettings, display: &TraceDisplay, size: [u32; 2], samples: u32, ) -> Result<(u32, u32, Vec), String> { self.set_scene(device, queue, scene)?; let encoder = || device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("tc_trace") }); let mut enc = encoder(); self.sync_materials(device, queue, &mut enc, renderer)?; self.reset(device, &mut enc, size[0], size[1])?; queue.submit([enc.finish()]); let (w, h) = self.acc.as_ref().map_or((1, 1), |a| (a.width, a.height)); // Several samples per dispatch on small renders; about one at 1080p (short GPU jobs). let chunk = (16_000_000 / (w * h).max(1)).clamp(1, 16); while self.samples < samples { let mut enc = encoder(); if !self.pass(device, queue, &mut enc, cam, settings, chunk.min(samples - self.samples)) { return Err("GPU path tracing: the scene is incomplete".into()); } queue.submit([enc.finish()]); } let out = Self::output_texture(device, w, h); let mut enc = encoder(); self.resolve(device, queue, &mut enc, display, &out.create_view(&Default::default())); queue.submit([enc.finish()]); crate::readback::Readback::blocking(device, queue, &out).ok_or_else(|| "GPU path tracing: could not read the render back".into()) } } /// GPU buffers of the mesh: (BVH nodes, triangles in BVH order), vertices. type GeometryData = ((Vec<[u32; 4]>, Vec<[u32; 4]>), Vec<[f32; 4]>); fn geometry_data(mesh: &Mesh, bvh: &texturecraft_geom::Bvh, tri_set: &[usize]) -> GeometryData { let vcount = mesh.positions.len(); let rows = bvh_rows(bvh, (0, 0), |o| { let idx = [0, 1, 2].map(|k| mesh.indices.get(o * 3 + k).copied().filter(|i| (*i as usize) < vcount).unwrap_or(0)); let set = tri_set.get(o).copied().filter(|s| *s < MAX_SETS).map_or(u32::MAX, |s| s as u32); let sign: f32 = mesh.tangents.get(idx[0] as usize).map_or(1.0, |t| if t.w < 0.0 { -1.0 } else { 1.0 }); ([set, sign.to_bits(), 0], [idx[0], idx[1], idx[2], o as u32]) }); let verts: Vec<[f32; 4]> = (0..vcount.max(1)) .flat_map(|v| { let n = mesh.normals.get(v).copied().unwrap_or(Vec3::ZERO); let uv = mesh.uvs.get(v).copied().unwrap_or_default(); let t = mesh.tangents.get(v).copied().unwrap_or(Vec4::X); [[n.x, n.y, n.z, uv.x], [t.x, t.y, t.z, uv.y]] }) .collect(); (rows, verts) } /// `bvh` in the layout of `shaders/rays.wgsl`, numbered from `base` (first node, first /// triangle) so several BVHs can share one buffer: per node (lo, first), (hi, count); per /// triangle (p0, w0), (p1, w1), (p2, w2), `last`, where `(w, last) = per_tri(original index)`. /// An empty BVH gets one leaf over one degenerate triangle. pub(crate) fn bvh_rows( bvh: &texturecraft_geom::Bvh, (node_base, tri_base): (u32, u32), per_tri: impl Fn(usize) -> ([u32; 3], [u32; 4]), ) -> (Vec<[u32; 4]>, Vec<[u32; 4]>) { let (tris, order) = bvh.triangles(); if tris.is_empty() { return (vec![bits(Vec3::ZERO, tri_base), bits(Vec3::ZERO, 1)], vec![[0; 4]; 4]); } let nodes = bvh .nodes() .flat_map(|(lo, hi, first, count)| [bits(lo, first.saturating_add(if count > 0 { tri_base } else { node_base })), bits(hi, count)]) .collect(); let rows = tris .iter() .zip(order) .flat_map(|(t, &orig)| { let (w, last) = per_tri(orig as usize); [bits(t[0], w[0]), bits(t[1], w[1]), bits(t[2], w[2]), last] }) .collect(); (nodes, rows) } #[cfg(test)] mod tests { use super::*; use crate::headless::Headless; use crate::trace::{TraceSet, Tracer}; use texturecraft_compose::{BakedMaps, Composite, all_tiles, tile_bytes}; use texturecraft_core::Channel; use texturecraft_geom::{Bvh, primitives}; fn camera() -> OrbitCamera { let mut cam = OrbitCamera::default(); cam.distance = 4.0; cam } /// A sphere whose one texture set holds the uniform channel `values`, that set uploaded to /// the headless renderer. fn sphere_scene(h: &mut Headless, env: EnvImage, values: &[(Channel, [f32; 3])]) -> TraceScene { let chans: Vec = values.iter().map(|(c, _)| *c).collect(); let mut composite = Composite::new(&chans, 64); for (c, v) in values { let raw: Vec = v[..c.components()].iter().map(|x| texturecraft_texel::to_u16(*x)).collect(); let img = composite.channels.get_mut(c).unwrap(); for y in 0..64 { for x in 0..64 { img.set(x, y, &raw); } } } h.renderer.set_texture_sets(&h.device, &h.queue, &[((64, 64), 0)], 1); for (tx, ty) in all_tiles(64, 64) { for k in DisplayKind::ALL { h.renderer.upload_tile(&h.device, &h.queue, 0, k, tx, ty, &tile_bytes(&composite, &BakedMaps::default(), k, tx, ty)); } } let mesh = Arc::new(primitives::sphere(1.0, 32, 16)); let bvh = Arc::new(Bvh::new(&mesh)); TraceScene::new(mesh, bvh, vec![TraceSet { material: 0, composite, height_strength: 0.0 }], Arc::new(env), 0.0) } fn gpu() -> Option<(Headless, GpuTracer)> { let Ok(h) = Headless::new() else { eprintln!("skipping: no GPU adapter"); return None; }; let t = match GpuTracer::new(&h.device) { Ok(t) => t, Err(e) if !GpuTracer::supported(&h.device) => { eprintln!("skipping: {e}"); return None; } Err(e) => panic!("{e}"), }; Some((h, t)) } /// The radiance accumulation, read back. fn accumulation(h: &Headless, t: &GpuTracer) -> Vec<[f32; 4]> { read_buffer(h, &t.acc.as_ref().unwrap().acc[0]) } /// Read a completed buffer to check its contents across resets and reuse. fn read_buffer(headless: &Headless, buffer: &wgpu::Buffer) -> Vec<[f32; 4]> { let bytes = buffer.size(); let staging = headless.device.create_buffer(&wgpu::BufferDescriptor { label: None, size: bytes, usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ, mapped_at_creation: false, }); let mut encoder = headless.device.create_command_encoder(&Default::default()); encoder.copy_buffer_to_buffer(buffer, 0, &staging, 0, bytes); headless.queue.submit([encoder.finish()]); staging.slice(..).map_async(wgpu::MapMode::Read, |_| {}); headless.device.poll(wgpu::PollType::Wait { submission_index: None, timeout: None }).unwrap(); bytemuck::cast_slice(&staging.slice(..).get_mapped_range().unwrap()).to_vec() } /// Two cached sizes reuse cleared buffers, and leaving Rendering mode releases both. #[test] fn switching_between_two_sizes_reuses_the_accumulation_buffers() { let Some((headless, mut tracer)) = gpu() else { return }; for (width, height) in [(64, 48), (32, 24), (64, 48), (32, 24), (64, 48)] { let mut encoder = headless.device.create_command_encoder(&Default::default()); tracer.reset(&headless.device, &mut encoder, width, height).unwrap(); headless.queue.submit([encoder.finish()]); let accumulation = tracer.acc.as_ref().unwrap(); assert_eq!((accumulation.width, accumulation.height), (width, height)); assert_eq!(tracer.samples(), 0); for buffer in accumulation.acc.iter().chain(&accumulation.illum) { assert!(read_buffer(&headless, buffer).iter().all(|pixel| *pixel == [0.0; 4]), "reused buffers must be cleared"); // Leave nonzero contents to detect stale pixels on the next reuse let pixels = vec![[1.0f32; 4]; (width * height) as usize]; headless.queue.write_buffer(buffer, 0, bytemuck::cast_slice(&pixels)); } tracer.samples = 7; } assert_eq!(tracer.acc_allocations, 2, "two sizes, two allocations, however often it switches"); let mut encoder = headless.device.create_command_encoder(&Default::default()); tracer.reset(&headless.device, &mut encoder, 16, 16).unwrap(); headless.queue.submit([encoder.finish()]); assert_eq!(tracer.acc_allocations, 3, "a third size allocates (and drops the oldest set)"); tracer.release(); assert!(tracer.acc.is_none() && tracer.spare_acc.is_none(), "leaving Rendering mode frees both sizes"); } /// Rejecting an oversized render preserves the image and lets tracing continue. #[test] fn failed_reset_retains_the_active_render() { let Some((mut headless, mut tracer)) = gpu() else { return }; let scene = sphere_scene(&mut headless, crate::ibl::environment("Studio Soft", 32), &WHITE); let camera = camera(); let settings = TraceSettings::default(); let display = TraceDisplay::from_display(&Default::default()); tracer.render(&headless.device, &headless.queue, &headless.renderer, &scene, &camera, &settings, &display, [32, 24], 2).unwrap(); let before = accumulation(&headless, &tracer); let mut encoder = headless.device.create_command_encoder(&Default::default()); let error = tracer.reset(&headless.device, &mut encoder, 8192, 8192).unwrap_err(); assert!(error.contains("exceeds this GPU's buffer limit")); assert!(tracer.acc.is_some(), "a rejected resize must keep the active buffers"); assert!(tracer.bind.is_some(), "a rejected resize must keep the active bindings"); assert_eq!(tracer.samples(), 2, "a rejected resize must keep the accumulated samples"); assert_eq!(accumulation(&headless, &tracer), before); assert!(tracer.pass(&headless.device, &headless.queue, &mut encoder, &camera, &settings, 1)); let output = GpuTracer::output_texture(&headless.device, 32, 24); assert!(tracer.resolve(&headless.device, &headless.queue, &mut encoder, &display, &output.create_view(&Default::default()))); headless.queue.submit([encoder.finish()]); assert!(crate::readback::Readback::blocking(&headless.device, &headless.queue, &output).is_some()); assert_eq!(tracer.samples(), 3); } const WHITE: [(Channel, [f32; 3]); 3] = [(Channel::BaseColor, [1.0; 3]), (Channel::Metallic, [0.0; 3]), (Channel::Roughness, [0.5; 3])]; #[test] fn white_furnace_on_the_gpu_stays_bounded_and_finite() { // White spheres in a uniform white environment reflect at most what arrives: at half // exposure the environment shows as 0.5 and the spheres between 0.25 and 0.5. use Channel::*; let Some((mut h, mut t)) = gpu() else { return }; let everything = [(CoatWeight, [1.0; 3]), (SheenWeight, [1.0; 3]), (AnisotropyLevel, [1.0; 3]), (ScatterWeight, [1.0; 3])]; for (name, extra) in [("white", &[][..]), ("every lobe", &everything[..])] { let values: Vec<_> = WHITE.iter().chain(extra).copied().collect(); let env = EnvImage { width: 8, height: 4, data: vec![[1.0; 3]; 32] }; let scene = sphere_scene(&mut h, env, &values); let d = TraceDisplay { exposure: 0.5, aces: false, env_opacity: 1.0, denoise: false }; let (w, _, px) = t.render(&h.device, &h.queue, &h.renderer, &scene, &camera(), &TraceSettings { bounces: 8 }, &d, [64, 48], 256).unwrap(); assert!(accumulation(&h, &t).iter().all(|v| v.iter().all(|c| c.is_finite())), "{name}: no NaN or infinity"); let at = |x: u32, y: u32| texturecraft_texel::srgb_to_linear(px[((y * w + x) * 4 + 1) as usize] as f32 / 255.0); assert!((at(0, 0) - 0.5).abs() < 0.02, "{name}: background {}", at(0, 0)); let block: Vec = (18..30).flat_map(|y| (26..38).map(move |x| (x, y))).map(|(x, y)| at(x, y)).collect(); let mean = block.iter().sum::() / block.len() as f32; assert!(mean > 0.25 && mean <= 0.5 * 1.05, "{name}: sphere {mean}"); } } #[test] fn gpu_matches_cpu_with_every_lobe_glass_and_lens() { use Channel::*; let Some((mut h, mut t)) = gpu() else { return }; let values = [ (BaseColor, [0.8, 0.5, 0.3]), (Roughness, [0.35; 3]), (CoatWeight, [0.8; 3]), (CoatRoughness, [0.15; 3]), (SheenWeight, [0.6; 3]), (SheenColor, [0.4, 0.6, 1.0]), (AnisotropyLevel, [0.8; 3]), (AnisotropyAngle, [0.2; 3]), (ScatterWeight, [0.7; 3]), ]; let glass = [(BaseColor, [0.9, 0.95, 1.0]), (Roughness, [0.2; 3]), (Transmission, [0.9; 3]), (CoatWeight, [0.6; 3]), (CoatNormal, [0.65, 0.5, 0.977])]; for (name, values, lens) in [("every lobe", &values[..], None), ("glass under a thin lens", &glass[..], Some([3.2, 0.2]))] { let mut scene = sphere_scene(&mut h, crate::ibl::environment("Studio Contrast", 256), values); (scene.lens, scene.ior) = (lens, 1.45); let d = TraceDisplay { exposure: 1.0, aces: true, env_opacity: 0.5, denoise: false }; let settings = TraceSettings { bounces: 6 }; let (_, _, gpu) = t.render(&h.device, &h.queue, &h.renderer, &scene, &camera(), &settings, &d, [48, 36], 1024).unwrap(); let mut cpu = Tracer::new(48, 36); for _ in 0..1024 { cpu.pass(&scene, &camera(), &settings); } assert_region_means_match(name, &gpu, &cpu.rgba8(&d), 48, 36, 3.0); } } #[test] fn gpu_reads_full_size_channels_beside_placeholders() { // Base color stays at its default (a 1×1 placeholder texture) while roughness varies // across the surface (a full-size texture): the tracer must still read every texel of it. use Channel::*; let Some((mut h, mut t)) = gpu() else { return }; let mut composite = Composite::new(&[Roughness, Metallic], 64); for y in 0..64 { for x in 0..64 { let rough = if x < 32 { 0.05 } else { 0.9 }; composite.channels.get_mut(&Roughness).unwrap().set(x, y, &[texturecraft_texel::to_u16(rough)]); composite.channels.get_mut(&Metallic).unwrap().set(x, y, &[texturecraft_texel::to_u16(1.0)]); } } h.renderer.set_texture_sets(&h.device, &h.queue, &[((64, 64), 0)], 1); for (tx, ty) in all_tiles(64, 64) { for k in DisplayKind::ALL { h.renderer.upload_tile(&h.device, &h.queue, 0, k, tx, ty, &tile_bytes(&composite, &BakedMaps::default(), k, tx, ty)); } } let sizes: Vec = h.renderer.display_textures()[0].iter().map(|t| t.width()).collect(); assert_eq!(sizes[0], 1, "base color stays a placeholder"); assert_eq!(sizes[1], 64, "roughness and metallic are full size"); let mesh = Arc::new(primitives::sphere(1.0, 32, 16)); let bvh = Arc::new(Bvh::new(&mesh)); let env = crate::ibl::environment("Studio Contrast", 256); let scene = TraceScene::new(mesh, bvh, vec![TraceSet { material: 0, composite, height_strength: 0.0 }], Arc::new(env), 0.0); let d = TraceDisplay { exposure: 1.0, aces: true, env_opacity: 0.5, denoise: false }; let settings = TraceSettings { bounces: 4 }; let (_, _, gpu) = t.render(&h.device, &h.queue, &h.renderer, &scene, &camera(), &settings, &d, [48, 36], 1024).unwrap(); let mut cpu = Tracer::new(48, 36); for _ in 0..1024 { cpu.pass(&scene, &camera(), &settings); } assert_region_means_match("varying roughness, default base color", &gpu, &cpu.rgba8(&d), 48, 36, 3.0); } /// Mean luminance of each 6×6 block of two RGBA8 renders agrees within `tol` 8-bit levels. fn assert_region_means_match(name: &str, a: &[u8], b: &[u8], w: usize, h: usize, tol: f32) { let lum = |img: &[u8], x: usize, y: usize| { let p = &img[(y * w + x) * 4..(y * w + x) * 4 + 3]; 0.2126 * p[0] as f32 + 0.7152 * p[1] as f32 + 0.0722 * p[2] as f32 }; let mut worst = 0.0f32; for by in (0..h).step_by(6) { for bx in (0..w).step_by(6) { let (mut sa, mut sb, mut n) = (0.0, 0.0, 0.0); for y in by..(by + 6).min(h) { for x in bx..(bx + 6).min(w) { sa += lum(a, x, y); sb += lum(b, x, y); n += 1.0; } } worst = worst.max(((sa - sb) / n).abs()); } } assert!(worst < tol, "{name}: worst block differs by {worst} levels"); } /// Samples per second at 1080p on the material ball, GPU against CPU: /// `cargo test -p texturecraft-render --release --lib -- --ignored --nocapture speed`. #[test] #[ignore] fn speed_at_1080p() { let Some((h, mut t)) = gpu() else { return }; let mesh = Arc::new(primitives::material_ball()); let (lo, hi) = mesh.bounds(); let mut cam = OrbitCamera::default(); cam.frame(lo, hi); let scene = TraceScene::new(mesh.clone(), Arc::new(Bvh::new(&mesh)), Vec::new(), Arc::new(crate::ibl::environment("Studio Soft", 1024)), 0.0); let (settings, d) = (TraceSettings::default(), TraceDisplay { exposure: 1.0, aces: true, env_opacity: 0.0, denoise: true }); let run = |t: &mut GpuTracer, n| t.render(&h.device, &h.queue, &h.renderer, &scene, &cam, &settings, &d, [1920, 1080], n).unwrap(); run(&mut t, 8); let t0 = std::time::Instant::now(); run(&mut t, 8); let base = t0.elapsed().as_secs_f64(); let t0 = std::time::Instant::now(); run(&mut t, 520); let gpu = 512.0 / (t0.elapsed().as_secs_f64() - base); let mut cpu_t = Tracer::new(1920, 1080); cpu_t.pass(&scene, &cam, &settings); let t0 = std::time::Instant::now(); for _ in 0..16 { cpu_t.pass(&scene, &cam, &settings); } let cpu = 16.0 / t0.elapsed().as_secs_f64(); eprintln!("1080p material ball: GPU {gpu:.0} samples/s, CPU {cpu:.1} samples/s, {:.1}x", gpu / cpu); } #[test] fn bvh_depth_counts_levels_and_rejects_cycles() { let leaf = (Vec3::ZERO, Vec3::ONE, 0, 1); let inner = (Vec3::ZERO, Vec3::ONE, 1, 0); assert_eq!(bvh_depth(&[leaf]), Some(1)); assert_eq!(bvh_depth(&[inner, leaf, leaf]), Some(2)); assert_eq!(bvh_depth(&[(Vec3::ZERO, Vec3::ONE, 0, 0), leaf]), None, "a node that is its own child"); } }