mirror of
https://github.com/storytold/texturecraft.git
synced 2026-11-19 22:10:42 +01:00
1072 lines
51 KiB
Rust
1072 lines
51 KiB
Rust
//! 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::<Head>() + 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<Mesh>,
|
||
tri_set: Arc<Vec<usize>>,
|
||
nodes: wgpu::Buffer,
|
||
tris: wgpu::Buffer,
|
||
verts: wgpu::Buffer,
|
||
}
|
||
|
||
struct EnvGpu {
|
||
image: Arc<EnvImage>,
|
||
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<f32>,
|
||
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<Geometry>,
|
||
env: Option<EnvGpu>,
|
||
materials: Option<Materials>,
|
||
acc: Option<Accum>,
|
||
/// Keep the preceding size so motion/full-resolution switches can reuse allocations.
|
||
spare_acc: Option<Accum>,
|
||
/// How many sets of accumulation buffers were allocated (for tests).
|
||
#[cfg(test)]
|
||
acc_allocations: u32,
|
||
scene: Option<SceneConst>,
|
||
bind: Option<wgpu::BindGroup>,
|
||
samples: u32,
|
||
}
|
||
|
||
/// The error a scope caught, if wgpu reported it at once (native backends do).
|
||
fn caught(f: impl Future<Output = Option<wgpu::Error>>) -> Option<wgpu::Error> {
|
||
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<T>(device: &wgpu::Device, what: &str, f: impl FnOnce() -> T) -> Result<T, String> {
|
||
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<T> {
|
||
/// wgpu answered at once (native backends, WebGL): the value, or what went wrong.
|
||
Done(Result<T, String>),
|
||
/// 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<Option<String>>),
|
||
}
|
||
|
||
/// [`scoped`] for work whose errors may arrive later: never takes an unanswered scope as success.
|
||
pub(crate) fn checked<T>(device: &wgpu::Device, what: &str, f: impl FnOnce() -> T) -> Checked<T> {
|
||
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<usize> {
|
||
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<GpuTracer, String> {
|
||
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::<PostRaw>() 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<bool, String> {
|
||
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::<PostRaw>())) {
|
||
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::<PostRaw>() 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<u8>), 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<Channel> = values.iter().map(|(c, _)| *c).collect();
|
||
let mut composite = Composite::new(&chans, 64);
|
||
for (c, v) in values {
|
||
let raw: Vec<u16> = 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<f32> = (18..30).flat_map(|y| (26..38).map(move |x| (x, y))).map(|(x, y)| at(x, y)).collect();
|
||
let mean = block.iter().sum::<f32>() / 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<u32> = 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");
|
||
}
|
||
}
|