use std::borrow::Cow;
use std::collections::HashMap;
use std::sync::Arc;
use crate::math::Vector3;
use crate::textures::TextureWrap;
use super::backend::{RaytraceBackend, RaytraceError};
use super::bsdf::ggx_albedo_table;
use super::camera::RtCamera;
use super::film::Film;
use super::scene::{RaytraceScene, RtLight, RtMaterial};
use super::settings::{BackgroundMode, RaytraceSettings};
use super::texture::CpuTexture;
const MAT_STRIDE: usize = 72;
const LIGHT_STRIDE: usize = 20;
const TRI_STRIDE: usize = 24;
const EMIT_STRIDE: usize = 2;
const ACCUM_STRIDE: usize = 14;
const ATLAS_SIZE: u32 = 4096;
const ATLAS_PAD: u32 = 2;
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct Uniforms {
cam_pos: [f32; 4],
cam_right: [f32; 4],
cam_up: [f32; 4],
cam_forward: [f32; 4],
inv_view: [f32; 16],
inv_proj: [f32; 16],
background: [f32; 4],
ambient: [f32; 4],
dims: [u32; 4],
counts: [u32; 4],
data_offsets: [u32; 4],
idx_offsets: [u32; 4],
params: [f32; 4],
adaptive: [f32; 4],
limits: [u32; 4],
flags: [u32; 4],
env_offsets: [u32; 4],
env_dims: [u32; 4],
env_rect: [[f32; 4]; 6],
hemi: [[f32; 4]; 12],
albedo_lut: [[f32; 4]; 256],
}
struct Packed {
nodes: Vec<f32>,
data: Vec<f32>,
idx: Vec<u32>,
tri_base: u32,
emissive_base: u32,
material_base: u32,
light_base: u32,
order_base: u32,
tri_material_base: u32,
emissive_slot_base: u32,
emissive_tri_base: u32,
atlas: Atlas,
env_func_base: u32,
env_cond_base: u32,
env_marg_base: u32,
env_dist_width: u32,
env_dist_height: u32,
env_dist_total: f32,
env_rect: [[f32; 4]; 6],
env_packed: bool,
hemi: [[f32; 4]; 12],
hemi_count: u32,
notes: Vec<String>,
}
struct SceneResources {
bind_group: wgpu::BindGroup,
accum: wgpu::Buffer,
uniform: wgpu::Buffer,
signature: (usize, usize, usize),
accum_len: usize,
accum_samples: Option<u32>,
}
pub struct GpuBackend {
device: Arc<wgpu::Device>,
queue: Arc<wgpu::Queue>,
layout: wgpu::BindGroupLayout,
pipeline: wgpu::ComputePipeline,
resources: Option<SceneResources>,
offsets: Option<Offsets>,
samples_per_dispatch: u32,
notes: Vec<String>,
}
impl std::fmt::Debug for GpuBackend {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("GpuBackend")
.field("samples_per_dispatch", &self.samples_per_dispatch)
.field("prepared", &self.resources.is_some())
.finish()
}
}
impl GpuBackend {
pub fn headless() -> Result<Self, RaytraceError> {
let mut instance_desc = wgpu::InstanceDescriptor::new_without_display_handle();
instance_desc.backends = wgpu::Backends::PRIMARY;
let instance = wgpu::Instance::new(instance_desc);
let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
compatible_surface: None,
force_fallback_adapter: false,
apply_limit_buckets: false,
}))
.map_err(|e| RaytraceError::NoDevice(format!("no wgpu adapter: {e}")))?;
let limits = adapter.limits();
let (device, queue) = pollster::block_on(adapter.request_device(
&wgpu::DeviceDescriptor {
label: Some("threers path tracer"),
required_features: wgpu::Features::empty(),
required_limits: limits,
..Default::default()
},
))
.map_err(|e| RaytraceError::NoDevice(format!("request_device failed: {e:?}")))?;
Ok(Self::with_device(Arc::new(device), Arc::new(queue)))
}
pub fn device_and_queue(&self) -> (Arc<wgpu::Device>, Arc<wgpu::Queue>) {
(Arc::clone(&self.device), Arc::clone(&self.queue))
}
pub fn with_device(device: Arc<wgpu::Device>, queue: Arc<wgpu::Queue>) -> Self {
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("threers pathtrace"),
source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("pathtrace.wgsl"))),
});
let storage = |binding: u32, read_only: bool| wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only },
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
};
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("threers pathtrace layout"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
storage(1, true),
storage(2, true),
storage(3, true),
storage(4, false),
wgpu::BindGroupLayoutEntry {
binding: 5,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
},
],
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("threers pathtrace pipeline layout"),
bind_group_layouts: &[Some(&layout)],
immediate_size: 0,
});
let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some("threers pathtrace"),
layout: Some(&pipeline_layout),
module: &shader,
entry_point: Some("trace"),
compilation_options: Default::default(),
cache: None,
});
Self {
device,
queue,
layout,
pipeline,
resources: None,
offsets: None,
samples_per_dispatch: 4,
notes: Vec::new(),
}
}
pub fn with_samples_per_dispatch(mut self, n: u32) -> Self {
self.samples_per_dispatch = n.max(1);
self
}
pub fn report(&self) -> &[String] {
&self.notes
}
pub fn device(&self) -> &Arc<wgpu::Device> {
&self.device
}
pub fn queue(&self) -> &Arc<wgpu::Queue> {
&self.queue
}
fn ensure_resources(
&mut self,
scene: &RaytraceScene,
film: &Film,
) -> Result<(), RaytraceError> {
let signature = (
scene.tris.len(),
scene.materials.len() << 20 | scene.lights.len() << 8 | scene.emissive.len().min(255),
(film.width() as usize) << 16 | film.height() as usize,
);
if let Some(r) = &self.resources {
if r.signature == signature {
return Ok(());
}
}
let packed = pack_scene(scene);
self.notes = packed.notes.clone();
let limits = self.device.limits();
let data_bytes = (packed.data.len() * 4) as u64;
if data_bytes > limits.max_storage_buffer_binding_size {
return Err(RaytraceError::TooLarge(format!(
"scene geometry is {} MB, past this device's {} MB storage-buffer limit",
data_bytes / (1 << 20),
limits.max_storage_buffer_binding_size / (1 << 20)
)));
}
let mk = |label: &str, contents: &[u8], usage: wgpu::BufferUsages| {
use wgpu::util::DeviceExt;
self.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some(label),
contents,
usage,
})
};
let nodes = if packed.nodes.is_empty() {
vec![0.0f32; 8]
} else {
packed.nodes
};
let data = if packed.data.is_empty() {
vec![0.0f32; 4]
} else {
packed.data
};
let idx = if packed.idx.is_empty() {
vec![0u32; 4]
} else {
packed.idx
};
let node_buf = mk(
"pathtrace nodes",
bytemuck::cast_slice(&nodes),
wgpu::BufferUsages::STORAGE,
);
let data_buf = mk(
"pathtrace data",
bytemuck::cast_slice(&data),
wgpu::BufferUsages::STORAGE,
);
let idx_buf = mk(
"pathtrace idx",
bytemuck::cast_slice(&idx),
wgpu::BufferUsages::STORAGE,
);
let accum_len = film.width() as usize * film.height() as usize * ACCUM_STRIDE;
let accum = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("pathtrace accum"),
size: (accum_len * 4) as u64,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let uniform = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("pathtrace uniforms"),
size: std::mem::size_of::<Uniforms>() as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let atlas_view = packed.atlas.upload(&self.device, &self.queue);
let bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("pathtrace bind group"),
layout: &self.layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: uniform.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: node_buf.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 2,
resource: data_buf.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 3,
resource: idx_buf.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 4,
resource: accum.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 5,
resource: wgpu::BindingResource::TextureView(&atlas_view),
},
],
});
self.resources = Some(SceneResources {
bind_group,
accum,
uniform,
signature,
accum_len,
accum_samples: None,
});
self.offsets = Some(Offsets {
tri_base: packed.tri_base,
emissive_base: packed.emissive_base,
material_base: packed.material_base,
light_base: packed.light_base,
order_base: packed.order_base,
tri_material_base: packed.tri_material_base,
emissive_slot_base: packed.emissive_slot_base,
emissive_tri_base: packed.emissive_tri_base,
env_func_base: packed.env_func_base,
env_cond_base: packed.env_cond_base,
env_marg_base: packed.env_marg_base,
env_dist_width: packed.env_dist_width,
env_dist_height: packed.env_dist_height,
env_dist_total: packed.env_dist_total,
env_rect: packed.env_rect,
env_packed: packed.env_packed,
hemi: packed.hemi,
hemi_count: packed.hemi_count,
});
Ok(())
}
}
#[derive(Clone, Copy)]
struct Offsets {
tri_base: u32,
emissive_base: u32,
material_base: u32,
light_base: u32,
order_base: u32,
tri_material_base: u32,
emissive_slot_base: u32,
emissive_tri_base: u32,
env_func_base: u32,
env_cond_base: u32,
env_marg_base: u32,
env_dist_width: u32,
env_dist_height: u32,
env_dist_total: f32,
env_rect: [[f32; 4]; 6],
env_packed: bool,
hemi: [[f32; 4]; 12],
hemi_count: u32,
}
impl RaytraceBackend for GpuBackend {
fn name(&self) -> &'static str {
"gpu"
}
fn invalidate(&mut self) {
self.resources = None;
self.offsets = None;
}
fn render(
&mut self,
scene: &RaytraceScene,
camera: &RtCamera,
settings: &RaytraceSettings,
film: &mut Film,
first_sample: u32,
samples: u32,
) -> Result<(), RaytraceError> {
if samples == 0 {
return Ok(());
}
self.ensure_resources(scene, film)?;
let (Some(res), Some(off)) = (self.resources.as_ref(), self.offsets) else {
return Err(RaytraceError::NoDevice("scene was not prepared".into()));
};
if res.accum_samples != Some(film.samples()) {
let mut seed_accum = vec![0.0f32; res.accum_len];
for (i, p) in film.pixels().iter().enumerate() {
let b = i * ACCUM_STRIDE;
seed_accum[b] = p.color[0];
seed_accum[b + 1] = p.color[1];
seed_accum[b + 2] = p.color[2];
seed_accum[b + 3] = p.alpha;
seed_accum[b + 4] = p.albedo[0];
seed_accum[b + 5] = p.albedo[1];
seed_accum[b + 6] = p.albedo[2];
seed_accum[b + 7] = p.normal[0];
seed_accum[b + 8] = p.normal[1];
seed_accum[b + 9] = p.normal[2];
seed_accum[b + 10] = p.depth;
seed_accum[b + 11] = p.depth_samples as f32;
}
self.queue
.write_buffer(&res.accum, 0, bytemuck::cast_slice(&seed_accum));
}
let epsilon = super::integrator::ray_epsilon(scene, settings);
let mut uniforms = build_uniforms(scene, camera, settings, film, &off, epsilon);
let groups_x = film.width().div_ceil(8);
let groups_y = film.height().div_ceil(8);
let mut done = 0u32;
while done < samples {
let batch = self.samples_per_dispatch.min(samples - done);
uniforms.dims[2] = first_sample + done;
uniforms.dims[3] = batch;
self.queue
.write_buffer(&res.uniform, 0, bytemuck::bytes_of(&uniforms));
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("pathtrace batch"),
});
{
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("pathtrace"),
timestamp_writes: None,
});
pass.set_pipeline(&self.pipeline);
pass.set_bind_group(0, &res.bind_group, &[]);
pass.dispatch_workgroups(groups_x, groups_y, 1);
}
self.queue.submit(Some(encoder.finish()));
done += batch;
}
let bytes = (res.accum_len * 4) as u64;
let staging = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("pathtrace readback"),
size: bytes,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
let mut encoder = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("pathtrace readback"),
});
encoder.copy_buffer_to_buffer(&res.accum, 0, &staging, 0, bytes);
self.queue.submit(Some(encoder.finish()));
let slice = staging.slice(..);
let (tx, rx) = std::sync::mpsc::channel();
slice.map_async(wgpu::MapMode::Read, move |r| {
let _ = tx.send(r);
});
let _ = self.device.poll(wgpu::PollType::wait_indefinitely());
match rx.recv() {
Ok(Ok(())) => {}
other => {
return Err(RaytraceError::DeviceLost(format!(
"readback failed: {other:?}"
)))
}
}
let mapped = slice.get_mapped_range().expect("buffer range is mapped");
let values: &[f32] = bytemuck::cast_slice(&mapped);
for (i, p) in film.pixels_mut().iter_mut().enumerate() {
let b = i * ACCUM_STRIDE;
p.color = [values[b], values[b + 1], values[b + 2]];
p.alpha = values[b + 3];
p.albedo = [values[b + 4], values[b + 5], values[b + 6]];
p.normal = [values[b + 7], values[b + 8], values[b + 9]];
p.depth = values[b + 10];
p.depth_samples = values[b + 11] as u32;
p.samples = values[b + 12] as u32;
p.lum_sq = values[b + 13];
}
drop(mapped);
staging.unmap();
film.advance(samples);
if let Some(res) = self.resources.as_mut() {
res.accum_samples = Some(film.samples());
}
Ok(())
}
}
fn build_uniforms(
scene: &RaytraceScene,
camera: &RtCamera,
settings: &RaytraceSettings,
film: &Film,
off: &Offsets,
epsilon: f32,
) -> Uniforms {
let inv_view = camera.inv_view_matrix();
let inv_proj = camera.inv_proj_matrix();
let pos = camera.position();
let right = camera.right();
let up = camera.up();
let fwd = camera.forward();
let mut lut = [[0.0f32; 4]; 256];
for (i, v) in ggx_albedo_table().iter().enumerate() {
lut[i / 4][i % 4] = *v;
}
let mut flags = 0u32;
if scene.world.has_environment() && off.env_packed {
flags |= 1;
}
if scene.shadows_all_opaque {
flags |= 2;
}
Uniforms {
cam_pos: [
pos.x,
pos.y,
pos.z,
if camera.is_perspective() { 1.0 } else { 0.0 },
],
cam_right: [right.x, right.y, right.z, settings.aperture],
cam_up: [up.x, up.y, up.z, camera.focus_distance()],
cam_forward: [fwd.x, fwd.y, fwd.z, epsilon],
inv_view: inv_view.elements,
inv_proj: inv_proj.elements,
background: [
scene.world.background.x,
scene.world.background.y,
scene.world.background.z,
scene.world.background_alpha,
],
ambient: [
scene.world.ambient.x,
scene.world.ambient.y,
scene.world.ambient.z,
scene.world.environment_intensity,
],
dims: [film.width(), film.height(), 0, 0],
counts: [
scene.tris.len() as u32,
scene.materials.len() as u32,
scene.lights.len() as u32,
scene.emissive.len() as u32,
],
data_offsets: [
off.tri_base,
off.emissive_base,
off.material_base,
off.light_base,
],
idx_offsets: [
off.order_base,
off.tri_material_base,
off.emissive_slot_base,
off.emissive_tri_base,
],
params: [
settings.clamp_direct,
settings.clamp_indirect,
off.env_dist_total,
0.0,
],
adaptive: [
settings.adaptive_threshold,
settings.adaptive_min_samples as f32,
0.0,
0.0,
],
limits: [
settings.max_bounces,
settings.min_bounces,
settings.transparent_max_bounces,
match settings.background {
BackgroundMode::Color => 0,
BackgroundMode::Environment => 1,
BackgroundMode::Transparent => 2,
},
],
flags: [
settings.seed as u32,
(settings.seed >> 32) as u32,
off.hemi_count,
flags,
],
env_offsets: [off.env_func_base, off.env_cond_base, off.env_marg_base, 0],
env_dims: [
off.env_dist_width,
off.env_dist_height,
u32::from(off.env_dist_width > 0 && (flags & 1) != 0),
0,
],
env_rect: off.env_rect,
hemi: off.hemi,
albedo_lut: lut,
}
}
struct Atlas {
pixels: Vec<u16>,
shelf_x: u32,
shelf_y: u32,
shelf_height: u32,
used_width: u32,
placed: HashMap<usize, [f32; 4]>,
}
impl Atlas {
fn new() -> Self {
Self {
pixels: Vec::new(),
shelf_x: 0,
shelf_y: 0,
shelf_height: 0,
used_width: 0,
placed: HashMap::new(),
}
}
fn insert_shared(&mut self, tex: &Arc<CpuTexture>) -> Option<[f32; 4]> {
let key = Arc::as_ptr(tex) as usize;
if let Some(rect) = self.placed.get(&key) {
return Some(*rect);
}
let rect = self.insert(tex)?;
self.placed.insert(key, rect);
Some(rect)
}
fn ensure_allocated(&mut self) {
if self.pixels.is_empty() {
self.pixels = vec![0u16; (ATLAS_SIZE * ATLAS_SIZE * 4) as usize];
}
}
fn insert(&mut self, tex: &CpuTexture) -> Option<[f32; 4]> {
let (w, h) = (tex.width(), tex.height());
if w == 0 || h == 0 || w > ATLAS_SIZE || h > ATLAS_SIZE {
return None;
}
if self.shelf_x + w + ATLAS_PAD > ATLAS_SIZE {
self.shelf_y += self.shelf_height + ATLAS_PAD;
self.shelf_x = 0;
self.shelf_height = 0;
}
if self.shelf_y + h > ATLAS_SIZE {
return None;
}
self.ensure_allocated();
let (x0, y0) = (self.shelf_x, self.shelf_y);
let flip = tex.flips_y();
for y in 0..h {
let src_y = if flip { h - 1 - y } else { y };
for x in 0..w {
let c = tex.texel_at(x, src_y);
let d = (((y0 + y) * ATLAS_SIZE + x0 + x) * 4) as usize;
for (dst, v) in self.pixels[d..d + 4].iter_mut().zip(c) {
*dst =
crate::renderer::gpu_texture::f32_to_f16_bits(v.clamp(-65504.0, 65504.0));
}
}
}
self.shelf_x += w + ATLAS_PAD;
self.used_width = self.used_width.max(x0 + w);
self.shelf_height = self.shelf_height.max(h);
Some([x0 as f32, y0 as f32, w as f32, h as f32])
}
fn upload(self, device: &wgpu::Device, queue: &wgpu::Queue) -> wgpu::TextureView {
let used_w = self.used_width.max(1);
let used_h = (self.shelf_y + self.shelf_height).max(1);
let mut pixels = vec![0u16; (used_w * used_h * 4) as usize];
if !self.pixels.is_empty() {
for y in 0..used_h {
let src = (y * ATLAS_SIZE * 4) as usize;
let dst = (y * used_w * 4) as usize;
let n = (used_w * 4) as usize;
pixels[dst..dst + n].copy_from_slice(&self.pixels[src..src + n]);
}
}
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: Some("pathtrace atlas"),
size: wgpu::Extent3d {
width: used_w,
height: used_h,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba16Float,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
});
queue.write_texture(
wgpu::TexelCopyTextureInfo {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
aspect: wgpu::TextureAspect::All,
},
bytemuck::cast_slice(&pixels),
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(used_w * 8),
rows_per_image: Some(used_h),
},
wgpu::Extent3d {
width: used_w,
height: used_h,
depth_or_array_layers: 1,
},
);
texture.create_view(&wgpu::TextureViewDescriptor::default())
}
}
fn wrap_code(w: TextureWrap) -> u32 {
match w {
TextureWrap::ClampToEdge => 0,
TextureWrap::Repeat => 1,
TextureWrap::MirroredRepeat => 2,
}
}
fn pack_scene(scene: &RaytraceScene) -> Packed {
let n_tris = scene.tris.len();
let mut atlas = Atlas::new();
let mut notes: Vec<String> = Vec::new();
let mut nodes = Vec::with_capacity(scene.bvh.node_count() * 8);
for i in 0..scene.bvh.node_count() {
let n = scene.bvh.node(i);
nodes.extend_from_slice(&[
n.min[0],
n.min[1],
n.min[2],
f32::from_bits(n.left_or_first),
n.max[0],
n.max[1],
n.max[2],
f32::from_bits(n.count),
]);
}
let mut data: Vec<f32> = Vec::with_capacity(n_tris * TRI_STRIDE + 4096);
let tri_base = 0u32;
for (i, t) in scene.tris.iter().enumerate() {
let sh = &scene.shading[i];
for v in t {
data.extend_from_slice(&[v.x, v.y, v.z]);
}
for n in &sh.normals {
data.extend_from_slice(&[n.x, n.y, n.z]);
}
for uv in &sh.uvs {
data.extend_from_slice(&[uv.x, uv.y]);
}
}
let emissive_base = data.len() as u32;
for e in &scene.emissive.tris {
let start = data.len();
data.resize(start + EMIT_STRIDE, 0.0);
data[start] = e.area;
data[start + 1] = e.cdf;
}
let material_base = data.len() as u32;
for (mi, m) in scene.materials.iter().enumerate() {
let start = data.len();
data.resize(start + MAT_STRIDE, 0.0);
let s = &mut data[start..start + MAT_STRIDE];
s[0] = m.base_color.x;
s[1] = m.base_color.y;
s[2] = m.base_color.z;
s[3] = m.opacity;
s[4] = m.emission.x;
s[5] = m.emission.y;
s[6] = m.emission.z;
s[7] = m.alpha_test;
s[8] = m.roughness;
s[9] = m.metallic;
s[10] = m.transmission;
s[11] = m.ior;
s[12] = m.attenuation_color.x;
s[13] = m.attenuation_color.y;
s[14] = m.attenuation_color.z;
s[15] = m.attenuation_distance;
s[16] = m.clearcoat;
s[17] = m.clearcoat_roughness;
s[18] = m.specular_tint.x;
s[19] = m.specular_tint.y;
s[20] = m.specular_tint.z;
s[21] = m.anisotropy;
s[22] = m.anisotropy_rotation;
s[23] = if m.unlit { 1.0 } else { 0.0 };
s[64] = m.normal_scale.x;
s[65] = m.normal_scale.y;
let mut wrap_bits = 0u32;
for (slot, tex) in material_maps(m).iter().enumerate() {
let Some(tex) = tex else { continue };
let o = 24 + slot * 8;
match atlas.insert_shared(tex) {
Some(rect) => {
s[o..o + 4].copy_from_slice(&rect);
let (offset, repeat, rotation) = tex.uv_transform();
s[o + 4] = offset.x;
s[o + 5] = offset.y;
s[o + 6] = repeat.x;
s[o + 7] = repeat.y;
let (wrap_s, wrap_t) = tex.wrap_modes();
wrap_bits |= wrap_code(wrap_s) << (slot * 2);
wrap_bits |= wrap_code(wrap_t) << (10 + slot * 2);
if rotation != 0.0 {
notes.push(format!(
"material {mi}, map {slot}: UV rotation is not applied by the GPU kernel"
));
}
}
None => notes.push(format!(
"material {mi}, map {slot}: {}x{} does not fit the atlas; the constant is used instead",
tex.width(),
tex.height()
)),
}
}
s[66] = wrap_bits as f32;
}
let light_base = data.len() as u32;
for l in &scene.lights {
let start = data.len();
data.resize(start + LIGHT_STRIDE, 0.0);
let s = &mut data[start..start + LIGHT_STRIDE];
match *l {
RtLight::Directional {
direction,
radiance,
angular_radius,
} => {
s[0] = 0.0;
write3(s, 1, direction);
write3(s, 4, radiance);
s[7] = angular_radius;
}
RtLight::Point {
position,
intensity,
radius,
distance,
decay,
} => {
s[0] = 1.0;
write3(s, 1, position);
write3(s, 4, intensity);
s[7] = radius;
s[11] = distance;
s[15] = decay;
}
RtLight::Spot {
position,
direction,
intensity,
radius,
distance,
decay,
cos_outer,
cos_inner,
} => {
s[0] = 2.0;
write3(s, 1, position);
write3(s, 4, intensity);
s[7] = radius;
write3(s, 8, direction);
s[11] = distance;
s[15] = decay;
s[16] = cos_outer;
s[17] = cos_inner;
}
RtLight::Rect {
position,
right,
up,
radiance,
} => {
s[0] = 3.0;
write3(s, 1, position);
write3(s, 4, radiance);
write3(s, 8, right);
write3(s, 12, up);
}
}
}
let mut env_func_base = 0u32;
let mut env_cond_base = 0u32;
let mut env_marg_base = 0u32;
let mut env_dist_width = 0u32;
let mut env_dist_height = 0u32;
let mut env_dist_total = 0.0f32;
if let Some(dist) = scene.world.env_distribution() {
let (func, cond, _row, marg) = dist.arrays();
env_func_base = data.len() as u32;
data.extend_from_slice(func);
env_cond_base = data.len() as u32;
data.extend_from_slice(cond);
env_marg_base = data.len() as u32;
data.extend_from_slice(marg);
env_dist_width = dist.width() as u32;
env_dist_height = dist.height() as u32;
env_dist_total = dist.total();
}
let order_base = 0u32;
let mut idx: Vec<u32> = Vec::with_capacity(n_tris * 3 + scene.emissive.len());
idx.extend_from_slice(scene.bvh.order());
let tri_material_base = idx.len() as u32;
idx.extend(scene.shading.iter().map(|s| s.material));
let emissive_slot_base = idx.len() as u32;
if scene.emissive.slots().len() == n_tris {
idx.extend_from_slice(scene.emissive.slots());
} else {
idx.resize(idx.len() + n_tris, u32::MAX);
}
let emissive_tri_base = idx.len() as u32;
idx.extend(scene.emissive.tris.iter().map(|e| e.triangle));
let mut env_rect = [[0.0f32; 4]; 6];
let mut env_packed = false;
if let Some(faces) = scene.world.env_faces() {
env_packed = true;
for (i, face) in faces.iter().enumerate() {
match atlas.insert(face) {
Some(rect) => env_rect[i] = rect,
None => env_packed = false,
}
}
if !env_packed {
env_rect = [[0.0f32; 4]; 6];
notes.push(
"environment map does not fit the texture atlas; the GPU backend renders no environment"
.into(),
);
}
}
let mut hemi = [[0.0f32; 4]; 12];
let hemi_count = scene.world.hemispheres.len().min(4);
for (i, h) in scene.world.hemispheres.iter().take(4).enumerate() {
hemi[i * 3] = [h.sky.x, h.sky.y, h.sky.z, 0.0];
hemi[i * 3 + 1] = [h.ground.x, h.ground.y, h.ground.z, 0.0];
hemi[i * 3 + 2] = [h.up.x, h.up.y, h.up.z, 0.0];
}
if scene.world.hemispheres.len() > 4 {
notes.push(format!(
"{} hemisphere lights; the GPU kernel carries 4",
scene.world.hemispheres.len()
));
}
Packed {
nodes,
data,
idx,
tri_base,
emissive_base,
material_base,
light_base,
order_base,
tri_material_base,
emissive_slot_base,
emissive_tri_base,
atlas,
env_func_base,
env_cond_base,
env_marg_base,
env_dist_width,
env_dist_height,
env_dist_total,
env_rect,
env_packed,
hemi,
hemi_count: hemi_count as u32,
notes,
}
}
fn material_maps(m: &RtMaterial) -> [Option<Arc<CpuTexture>>; 5] {
[
m.base_color_map.clone(),
m.roughness_map.clone(),
m.metallic_map.clone(),
m.emissive_map.clone(),
m.normal_map.clone(),
]
}
fn write3(s: &mut [f32], at: usize, v: Vector3) {
s[at] = v.x;
s[at + 1] = v.y;
s[at + 2] = v.z;
}
#[cfg(test)]
mod tests {
use super::*;
use crate::cameras::PerspectiveCamera;
use crate::core::{Mesh, Object3D};
use crate::geometries::{BoxGeometry, PlaneGeometry, SphereGeometry};
use crate::lights::{AmbientLight, DirectionalLight};
use crate::materials::{Material, StandardMaterial};
use crate::math::Color;
use crate::raytrace::backend::CpuBackend;
use crate::scene::Scene;
fn backend() -> Option<GpuBackend> {
match GpuBackend::headless() {
Ok(b) => Some(b),
Err(e) => {
eprintln!("skipping GPU test: {e}");
None
}
}
}
fn camera() -> PerspectiveCamera {
let mut c = PerspectiveCamera::new(50.0, 1.0, 0.1, 100.0);
c.position = Vector3::new(2.5, 2.0, 4.0);
c.target = Vector3::ZERO;
c
}
fn lit_box_scene() -> Scene {
let mut scene = Scene::new();
scene.background = Color::new(0.05, 0.06, 0.09);
scene.add(Object3D::mesh(Mesh::new(
BoxGeometry::new(2.0, 2.0, 2.0),
Material::Standard(StandardMaterial::new(Color::new(0.75, 0.35, 0.2))),
)));
let mut floor = Object3D::mesh(Mesh::new(
PlaneGeometry::new(20.0, 20.0),
Material::Standard(StandardMaterial::new(Color::new(0.6, 0.6, 0.6))),
));
floor.position = Vector3::new(0.0, -1.0, 0.0);
floor.rotate_x(-std::f32::consts::FRAC_PI_2);
scene.add(floor);
let mut sun = Object3D::light(DirectionalLight::new(Color::WHITE, 2.5));
sun.position = Vector3::new(3.0, 6.0, 4.0);
scene.add(sun);
scene.add_light(AmbientLight::new(Color::new(0.4, 0.5, 0.7), 0.3));
scene
}
fn mean_channel(hdr: &[f32], c: usize) -> f32 {
let mut sum = 0.0f64;
let mut n = 0usize;
for px in hdr.chunks_exact(4) {
sum += px[c] as f64;
n += 1;
}
(sum / n.max(1) as f64) as f32
}
#[test]
fn the_kernel_compiles_and_runs() {
let Some(mut gpu) = backend() else { return };
let mut scene = Scene::new();
scene.background = Color::new(0.25, 0.5, 0.75);
let settings = RaytraceSettings::default()
.with_samples(2)
.with_denoise(false);
let rt = RaytraceScene::build(&mut scene, &settings);
let cam = RtCamera::new(&camera(), &settings);
let mut film = Film::new(16, 16);
gpu.render(&rt, &cam, &settings, &mut film, 0, 2).unwrap();
let hdr = film.resolve_hdr();
assert!((hdr[0] - 0.25).abs() < 2e-3, "{:?}", &hdr[..4]);
assert!((hdr[1] - 0.5).abs() < 2e-3);
assert!((hdr[2] - 0.75).abs() < 2e-3);
assert!((hdr[3] - 1.0).abs() < 1e-4);
}
#[test]
fn gpu_furnace_test() {
let Some(mut gpu) = backend() else { return };
let mut scene = Scene::new();
scene.background = Color::BLACK;
scene.add(Object3D::mesh(Mesh::new(
PlaneGeometry::new(50.0, 50.0),
Material::Standard(StandardMaterial::new(Color::new(0.6, 0.6, 0.6))),
)));
scene.add_light(AmbientLight::new(Color::WHITE, 1.0));
let settings = RaytraceSettings {
samples_per_pixel: 256,
max_bounces: 1,
min_bounces: 1,
clamp_indirect: 0.0,
denoise: false,
..Default::default()
};
let rt = RaytraceScene::build(&mut scene, &settings);
let mut cam = PerspectiveCamera::new(50.0, 1.0, 0.1, 100.0);
cam.position = Vector3::new(0.0, 0.0, 4.0);
cam.target = Vector3::ZERO;
let rtc = RtCamera::new(&cam, &settings);
let mut film = Film::new(16, 16);
gpu.render(&rt, &rtc, &settings, &mut film, 0, 256).unwrap();
let hdr = film.resolve_hdr();
let i = (8 * 16 + 8) * 4;
assert!((hdr[i] - 0.6).abs() < 0.03, "expected 0.6, got {}", hdr[i]);
}
#[test]
fn gpu_and_cpu_agree_on_a_lit_scene() {
let Some(mut gpu) = backend() else { return };
let mut scene = lit_box_scene();
let settings = RaytraceSettings {
samples_per_pixel: 96,
max_bounces: 4,
min_bounces: 4,
clamp_indirect: 0.0,
denoise: false,
..Default::default()
};
let rt = RaytraceScene::build(&mut scene, &settings);
let cam = RtCamera::new(&camera(), &settings);
let mut gpu_film = Film::new(48, 48);
gpu.render(&rt, &cam, &settings, &mut gpu_film, 0, 96)
.unwrap();
let mut cpu_film = Film::new(48, 48);
CpuBackend::new()
.render(&rt, &cam, &settings, &mut cpu_film, 0, 96)
.unwrap();
let g = gpu_film.resolve_hdr();
let c = cpu_film.resolve_hdr();
for channel in 0..3 {
let gm = mean_channel(&g, channel);
let cm = mean_channel(&c, channel);
assert!(gm > 0.01, "channel {channel} rendered black on the GPU");
assert!(
(gm - cm).abs() < 0.06 * cm.max(0.05),
"channel {channel}: gpu mean {gm}, cpu mean {cm}"
);
}
let mut worst = 0.0f32;
for (a, b) in g.chunks_exact(4).zip(c.chunks_exact(4)) {
worst = worst.max((a[0] - b[0]).abs());
}
assert!(worst < 0.6, "worst per-pixel red difference {worst}");
}
#[test]
fn gpu_handles_emissive_geometry_and_glass() {
let Some(mut gpu) = backend() else { return };
let mut scene = Scene::new();
scene.background = Color::BLACK;
let mut emitter = StandardMaterial::new(Color::BLACK);
emitter.emissive = Color::WHITE;
emitter.emissive_intensity = 12.0;
let mut panel = Object3D::mesh(Mesh::new(
PlaneGeometry::new(2.0, 2.0),
Material::Standard(emitter),
));
panel.position = Vector3::new(0.0, 0.0, 3.0);
panel.rotate_y(std::f32::consts::PI);
scene.add(panel);
let mut glass = crate::materials::PhysicalMaterial::new(Color::WHITE);
glass.transmission = 1.0;
glass.roughness = 0.05;
glass.ior = 1.5;
scene.add(Object3D::mesh(Mesh::new(
SphereGeometry::new(0.8, 24, 16),
Material::Physical(glass),
)));
let mut wall = Object3D::mesh(Mesh::new(
PlaneGeometry::new(20.0, 20.0),
Material::Standard(StandardMaterial::new(Color::new(0.7, 0.7, 0.7))),
));
wall.position = Vector3::new(0.0, 0.0, -3.0);
scene.add(wall);
let settings = RaytraceSettings {
samples_per_pixel: 32,
max_bounces: 6,
denoise: false,
..Default::default()
};
let rt = RaytraceScene::build(&mut scene, &settings);
assert!(!rt.emissive.is_empty());
let mut cam = PerspectiveCamera::new(50.0, 1.0, 0.1, 100.0);
cam.position = Vector3::new(0.0, 0.0, 6.0);
cam.target = Vector3::ZERO;
let rtc = RtCamera::new(&cam, &settings);
let mut film = Film::new(32, 32);
gpu.render(&rt, &rtc, &settings, &mut film, 0, 32).unwrap();
let hdr = film.resolve_hdr();
assert!(
hdr.iter().all(|v| v.is_finite() && *v >= 0.0),
"non-finite output"
);
assert!(mean_channel(&hdr, 0) > 0.005, "the emitter lit nothing");
}
#[test]
fn gpu_accumulation_is_additive() {
let Some(mut gpu) = backend() else { return };
let mut scene = lit_box_scene();
let settings = RaytraceSettings {
samples_per_pixel: 32,
max_bounces: 3,
denoise: false,
..Default::default()
};
let rt = RaytraceScene::build(&mut scene, &settings);
let cam = RtCamera::new(&camera(), &settings);
let mut one = Film::new(24, 24);
gpu.render(&rt, &cam, &settings, &mut one, 0, 32).unwrap();
let mut split = Film::new(24, 24);
gpu.render(&rt, &cam, &settings, &mut split, 0, 12).unwrap();
gpu.render(&rt, &cam, &settings, &mut split, 12, 20)
.unwrap();
assert_eq!(split.samples(), 32);
let a = one.resolve_hdr();
let b = split.resolve_hdr();
for (i, (x, y)) in a.iter().zip(b.iter()).enumerate() {
assert!(
(x - y).abs() < 1e-4,
"channel {i}: {x} vs {y} — batching changed the sample sequence"
);
}
}
#[test]
fn gpu_clear_glass_passes_light_through() {
let Some(mut gpu) = backend() else { return };
let build = |with_ball: bool| {
let mut scene = Scene::new();
scene.background = Color::BLACK;
let mut em = StandardMaterial::new(Color::BLACK);
em.emissive = Color::WHITE;
em.emissive_intensity = 4.0;
let mut wall = Object3D::mesh(Mesh::new(
PlaneGeometry::new(20.0, 20.0),
Material::Standard(em),
));
wall.position = Vector3::new(0.0, 0.0, -4.0);
scene.add(wall);
if with_ball {
let mut glass = crate::materials::PhysicalMaterial::new(Color::WHITE);
glass.transmission = 1.0;
glass.roughness = 0.0;
glass.ior = 1.52;
scene.add(Object3D::mesh(Mesh::new(
SphereGeometry::new(1.0, 48, 32),
Material::Physical(glass),
)));
}
scene
};
let settings = RaytraceSettings {
samples_per_pixel: 64,
max_bounces: 12,
min_bounces: 8,
clamp_indirect: 0.0,
denoise: false,
..Default::default()
};
let mut cam = PerspectiveCamera::new(50.0, 1.0, 0.1, 100.0);
cam.position = Vector3::new(0.0, 0.0, 5.0);
cam.target = Vector3::ZERO;
let mut centre = |with_ball: bool| {
let mut scene = build(with_ball);
let rt = RaytraceScene::build(&mut scene, &settings);
let rtc = RtCamera::new(&cam, &settings);
let mut film = Film::new(32, 32);
gpu.render(&rt, &rtc, &settings, &mut film, 0, 64).unwrap();
film.resolve_hdr()[(16 * 32 + 16) * 4]
};
let clear = centre(false);
let through_glass = centre(true);
assert!(
(clear - 4.0).abs() < 0.02,
"backdrop should read 4.0, got {clear}"
);
assert!(
through_glass > 0.85 * clear,
"glass passed only {through_glass} of {clear}"
);
}
#[test]
fn a_transparent_background_reaches_the_film() {
let Some(mut gpu) = backend() else { return };
let mut scene = Scene::new();
let settings = RaytraceSettings::default()
.with_samples(4)
.with_denoise(false)
.with_background(BackgroundMode::Transparent);
let rt = RaytraceScene::build(&mut scene, &settings);
let cam = RtCamera::new(&camera(), &settings);
let mut film = Film::new(8, 8);
gpu.render(&rt, &cam, &settings, &mut film, 0, 4).unwrap();
assert_eq!(film.resolve_hdr()[3], 0.0);
}
#[test]
fn gpu_matches_cpu_on_a_textured_surface() {
let Some(mut gpu) = backend() else { return };
let build = || {
let mut scene = Scene::new();
scene.background = Color::BLACK;
let n = 8u32;
let mut px = vec![0u8; (n * n * 4) as usize];
for y in 0..n {
for x in 0..n {
let on = (x + y) % 2 == 0;
let i = ((y * n + x) * 4) as usize;
px[i] = if on { 230 } else { 30 };
px[i + 1] = if on { 60 } else { 200 };
px[i + 2] = 90;
px[i + 3] = 255;
}
}
let mut tex = crate::textures::Texture::new(
n,
n,
crate::textures::TextureFormat::Rgba8UnormSrgb,
px,
);
tex.wrap_s = crate::textures::TextureWrap::Repeat;
tex.wrap_t = crate::textures::TextureWrap::Repeat;
tex.mag_filter = crate::textures::TextureFilter::Linear;
tex.repeat = crate::math::Vector2::new(3.0, 3.0);
tex.flip_y = false;
let mut m = StandardMaterial::new(Color::WHITE);
m.map = Some(std::sync::Arc::new(tex));
m.roughness = 0.8;
scene.add(Object3D::mesh(Mesh::new(
PlaneGeometry::new(6.0, 6.0),
Material::Standard(m),
)));
scene.add_light(AmbientLight::new(Color::WHITE, 1.0));
scene
};
let settings = RaytraceSettings {
samples_per_pixel: 64,
max_bounces: 2,
denoise: false,
..Default::default()
};
let mut cam = PerspectiveCamera::new(50.0, 1.0, 0.1, 100.0);
cam.position = Vector3::new(0.0, 0.0, 5.0);
cam.target = Vector3::ZERO;
let mut scene = build();
let rt = RaytraceScene::build(&mut scene, &settings);
assert!(
rt.shadows_all_opaque,
"an opaque map must keep the fast path"
);
let rtc = RtCamera::new(&cam, &settings);
let mut g = Film::new(48, 48);
gpu.render(&rt, &rtc, &settings, &mut g, 0, 64).unwrap();
let mut c = Film::new(48, 48);
CpuBackend::new()
.render(&rt, &rtc, &settings, &mut c, 0, 64)
.unwrap();
let (gh, ch) = (g.resolve_hdr(), c.resolve_hdr());
for channel in 0..3 {
let (gm, cm) = (mean_channel(&gh, channel), mean_channel(&ch, channel));
assert!(gm > 0.01, "channel {channel} came out black on the GPU");
assert!(
(gm - cm).abs() < 0.03 * cm.max(0.05),
"channel {channel}: gpu {gm}, cpu {cm} — the atlas is not sampling like the CPU"
);
}
let reds: Vec<f32> = gh.chunks_exact(4).map(|p| p[0]).collect();
let spread = reds.iter().cloned().fold(0.0f32, f32::max)
- reds.iter().cloned().fold(f32::MAX, f32::min);
assert!(
spread > 0.15,
"the texture flattened to a constant ({spread})"
);
}
#[test]
fn gpu_matches_cpu_with_an_environment_map() {
let Some(mut gpu) = backend() else { return };
let size = 8u32;
let mut faces: [Vec<u8>; 6] = Default::default();
let tints: [[u8; 3]; 6] = [
[220, 40, 40],
[40, 220, 40],
[40, 40, 220],
[220, 220, 40],
[220, 40, 220],
[40, 220, 220],
];
for (f, tint) in faces.iter_mut().zip(tints) {
let mut px = vec![255u8; (size * size * 4) as usize];
for p in px.chunks_exact_mut(4) {
p[0] = tint[0];
p[1] = tint[1];
p[2] = tint[2];
}
*f = px;
}
let cube = std::sync::Arc::new(crate::textures::CubeTexture::new(
size,
crate::textures::TextureFormat::Rgba8Unorm,
faces,
));
let mut scene = Scene::new();
scene.background = Color::BLACK;
scene.environment = Some(cube);
scene.add(Object3D::mesh(Mesh::new(
SphereGeometry::new(1.2, 32, 24),
Material::Standard(StandardMaterial::new(Color::new(0.8, 0.8, 0.8))),
)));
let settings = RaytraceSettings {
samples_per_pixel: 96,
max_bounces: 2,
denoise: false,
background: BackgroundMode::Environment,
..Default::default()
};
let rt = RaytraceScene::build(&mut scene, &settings);
assert!(rt.world.has_environment(), "the cube should have decoded");
let mut cam = PerspectiveCamera::new(50.0, 1.0, 0.1, 100.0);
cam.position = Vector3::new(0.0, 0.0, 4.0);
cam.target = Vector3::ZERO;
let rtc = RtCamera::new(&cam, &settings);
let mut g = Film::new(40, 40);
gpu.render(&rt, &rtc, &settings, &mut g, 0, 192).unwrap();
let mut c = Film::new(40, 40);
CpuBackend::new()
.render(&rt, &rtc, &settings, &mut c, 0, 96)
.unwrap();
let (gh, ch) = (g.resolve_hdr(), c.resolve_hdr());
for channel in 0..3 {
let (gm, cm) = (mean_channel(&gh, channel), mean_channel(&ch, channel));
assert!(
(gm - cm).abs() < 0.04 * cm.max(0.05),
"channel {channel}: gpu {gm}, cpu {cm} — cube mapping disagrees"
);
assert!(
gm < 0.95,
"channel {channel} reads {gm}: suspiciously white"
);
}
}
#[test]
fn gpu_importance_samples_the_environment() {
let Some(mut gpu) = backend() else { return };
use crate::raytrace::backend::sun::{sun_scene, sun_settings};
let mut cam = PerspectiveCamera::new(50.0, 1.0, 0.1, 100.0);
cam.position = Vector3::new(0.0, 0.0, 5.0);
cam.target = Vector3::ZERO;
let settings = sun_settings(64);
let mut scene = sun_scene();
let rt = RaytraceScene::build(&mut scene, &settings);
assert!(rt.world.env_distribution().is_some());
let rtc = RtCamera::new(&cam, &settings);
let mut g = Film::new(24, 24);
gpu.render(&rt, &rtc, &settings, &mut g, 0, 64).unwrap();
let mut c = Film::new(24, 24);
CpuBackend::new()
.render(&rt, &rtc, &settings, &mut c, 0, 64)
.unwrap();
let (gm, cm) = (
mean_channel(&g.resolve_hdr(), 0),
mean_channel(&c.resolve_hdr(), 0),
);
assert!(cm > 0.02, "the reference is not lit ({cm})");
assert!(
(gm - cm).abs() < 0.08 * cm,
"gpu {gm} vs cpu {cm} — the kernel is not sampling the sun"
);
}
#[test]
fn gpu_adaptive_sampling_matches_the_cpu() {
let Some(mut gpu) = backend() else { return };
let mut scene = lit_box_scene();
let settings = RaytraceSettings {
samples_per_pixel: 128,
max_bounces: 3,
adaptive_threshold: 0.02,
adaptive_min_samples: 16,
denoise: false,
..Default::default()
};
let rt = RaytraceScene::build(&mut scene, &settings);
let cam = RtCamera::new(&camera(), &settings);
let mut g = Film::new(32, 32);
gpu.render(&rt, &cam, &settings, &mut g, 0, 128).unwrap();
let mut c = Film::new(32, 32);
CpuBackend::new()
.render(&rt, &cam, &settings, &mut c, 0, 128)
.unwrap();
let (g_lo, g_hi) = g.sample_range();
let (c_lo, c_hi) = c.sample_range();
assert!(g_lo < 128, "the kernel stopped nothing ({g_lo}..{g_hi})");
assert!(c_lo < 128, "the CPU stopped nothing ({c_lo}..{c_hi})");
let total = |f: &Film| {
f.resolve_sample_counts()
.iter()
.map(|&n| n as f64)
.sum::<f64>()
};
let (gt, ct) = (total(&g), total(&c));
assert!(
(gt - ct).abs() < 0.2 * ct,
"budgets diverged: gpu {gt}, cpu {ct}"
);
let gm = mean_channel(&g.resolve_hdr(), 0);
let cm = mean_channel(&c.resolve_hdr(), 0);
assert!(
(gm - cm).abs() < 0.05 * cm.max(0.02),
"gpu {gm} vs cpu {cm}"
);
}
#[test]
fn gpu_and_cpu_map_the_cube_the_same_way() {
let Some(mut gpu) = backend() else { return };
let (w, h) = (256u32, 128u32);
let mut src = vec![0.0f32; (w * h * 4) as usize];
for y in 0..h {
let theta = (y as f32 + 0.5) / h as f32 * std::f32::consts::PI;
for x in 0..w {
let phi = ((x as f32 + 0.5) / w as f32 - 0.5) * 2.0 * std::f32::consts::PI;
let d = Vector3::new(
theta.sin() * phi.cos(),
theta.cos(),
theta.sin() * phi.sin(),
);
let i = ((y * w + x) * 4) as usize;
src[i] = 0.5 + 0.5 * d.x;
src[i + 1] = 0.5 + 0.5 * d.y;
src[i + 2] = 0.5 + 0.5 * d.z;
src[i + 3] = 1.0;
}
}
let cube = crate::extras::PmremGenerator::from_equirect_f32(&src, w, h, 128);
let mut scene = Scene::new();
scene.environment = Some(std::sync::Arc::new(cube));
let settings = RaytraceSettings {
samples_per_pixel: 4,
max_bounces: 0,
background: BackgroundMode::Environment,
adaptive_threshold: 0.0,
denoise: false,
..Default::default()
};
let rt = RaytraceScene::build(&mut scene, &settings);
for (i, target) in [
Vector3::new(1.0, 0.0, 0.0),
Vector3::new(-1.0, 0.0, 0.0),
Vector3::new(0.0, 1.0, 0.0),
Vector3::new(0.0, -1.0, 0.0),
Vector3::new(0.0, 0.0, 1.0),
Vector3::new(0.0, 0.0, -1.0),
]
.into_iter()
.enumerate()
{
let mut cam = PerspectiveCamera::new(60.0, 1.0, 0.1, 100.0);
cam.position = Vector3::ZERO;
cam.target = target;
cam.up = if target.y.abs() > 0.9 {
Vector3::new(0.0, 0.0, 1.0)
} else {
Vector3::new(0.0, 1.0, 0.0)
};
let rtc = RtCamera::new(&cam, &settings);
let mut g = Film::new(24, 24);
gpu.render(&rt, &rtc, &settings, &mut g, 0, 4).unwrap();
let mut c = Film::new(24, 24);
CpuBackend::new()
.render(&rt, &rtc, &settings, &mut c, 0, 4)
.unwrap();
let (gh, ch) = (g.resolve_hdr(), c.resolve_hdr());
let mut worst = 0.0f32;
for (a, b) in gh.chunks_exact(4).zip(ch.chunks_exact(4)) {
for k in 0..3 {
worst = worst.max((a[k] - b[k]).abs());
}
}
assert!(
worst < 0.03,
"looking at {target:?} (face {i}): worst channel difference {worst} \
— the two backends disagree about where the sky is"
);
}
}
#[test]
fn gpu_matches_cpu_on_an_hdr_environment() {
let Some(mut gpu) = backend() else { return };
let (w, h) = (256u32, 128u32);
let sun = Vector3::new(0.55, 0.62, 0.56).normalize();
let mut src = vec![0.0f32; (w * h * 4) as usize];
for y in 0..h {
let v = (y as f32 + 0.5) / h as f32;
let theta = v * std::f32::consts::PI;
for x in 0..w {
let u = (x as f32 + 0.5) / w as f32;
let phi = (u - 0.5) * 2.0 * std::f32::consts::PI;
let d = Vector3::new(
theta.sin() * phi.cos(),
theta.cos(),
theta.sin() * phi.sin(),
);
let i = ((y * w + x) * 4) as usize;
let c = if d.dot(sun) > 0.06f32.cos() {
[400.0, 380.0, 350.0]
} else {
[0.2 + 0.6 * u, 0.25 + 0.5 * v, 0.6]
};
src[i] = c[0];
src[i + 1] = c[1];
src[i + 2] = c[2];
src[i + 3] = 1.0;
}
}
let cube = crate::extras::PmremGenerator::from_equirect_f32(&src, w, h, 64);
let mut scene = Scene::new();
scene.environment = Some(std::sync::Arc::new(cube));
let mut m = StandardMaterial::new(Color::new(0.95, 0.95, 0.95));
m.roughness = 0.08;
m.metalness = 1.0;
scene.add(Object3D::mesh(Mesh::new(
SphereGeometry::new(1.2, 48, 32),
Material::Standard(m),
)));
let settings = RaytraceSettings {
samples_per_pixel: 192,
max_bounces: 2,
clamp_indirect: 0.0,
background: BackgroundMode::Environment,
adaptive_threshold: 0.0,
denoise: false,
..Default::default()
};
let rt = RaytraceScene::build(&mut scene, &settings);
assert!(rt.world.env_distribution().is_some());
let peak = rt.world.lighting_radiance(sun);
assert!(
peak.x > 300.0,
"the sun read back at {} — clamped somewhere",
peak.x
);
for (i, eye) in [Vector3::new(0.0, 0.0, 4.5), Vector3::new(4.5, 0.6, 0.0)]
.into_iter()
.enumerate()
{
let mut cam = PerspectiveCamera::new(70.0, 1.0, 0.1, 100.0);
cam.position = eye;
cam.target = Vector3::ZERO;
let rtc = RtCamera::new(&cam, &settings);
let mut g = Film::new(40, 40);
gpu.render(&rt, &rtc, &settings, &mut g, 0, 192).unwrap();
let mut c = Film::new(40, 40);
CpuBackend::new()
.render(&rt, &rtc, &settings, &mut c, 0, 192)
.unwrap();
let (gh, ch) = (g.resolve_hdr(), c.resolve_hdr());
for channel in 0..3 {
let (gm, cm) = (mean_channel(&gh, channel), mean_channel(&ch, channel));
assert!(cm > 0.05, "view {i} channel {channel} is not lit ({cm})");
assert!(
(gm - cm).abs() < 0.05 * cm,
"view {i} channel {channel}: gpu {gm}, cpu {cm} — the two disagree about the sky"
);
}
let tile_means = |v: &[f32], channel: usize| {
let mut tiles = [[0.0f64; 4]; 4];
let mut counts = [[0u32; 4]; 4];
for (p, px) in v.chunks_exact(4).enumerate() {
let (x, y) = (p % 40, p / 40);
let (tx, ty) = (x * 4 / 40, y * 4 / 40);
tiles[ty][tx] += px[channel] as f64;
counts[ty][tx] += 1;
}
let mut out = [[0.0f64; 4]; 4];
for y in 0..4 {
for x in 0..4 {
out[y][x] = tiles[y][x] / counts[y][x].max(1) as f64;
}
}
out
};
for channel in 0..3 {
let (gt, ct) = (tile_means(&gh, channel), tile_means(&ch, channel));
for y in 0..4 {
for x in 0..4 {
assert!(
(gt[y][x] - ct[y][x]).abs() < 0.18 * ct[y][x].max(0.05),
"view {i} channel {channel}, tile ({x},{y}): gpu {:.4} vs cpu {:.4} \
— the sky is in different places",
gt[y][x],
ct[y][x]
);
}
}
}
}
}
#[test]
fn gpu_converges_as_fast_as_the_cpu_at_low_sample_counts() {
let Some(mut gpu) = backend() else { return };
use crate::raytrace::backend::sun::{
area_light_camera, area_light_scene, area_light_settings,
};
let reference = {
let settings = area_light_settings(1024);
let mut scene = area_light_scene();
let rt = RaytraceScene::build(&mut scene, &settings);
let rtc = RtCamera::new(&area_light_camera(), &settings);
let mut film = Film::new(24, 24);
CpuBackend::new()
.render(&rt, &rtc, &settings, &mut film, 0, 1024)
.unwrap();
film.resolve_hdr()
};
let settings = area_light_settings(16);
let mut scene = area_light_scene();
let rt = RaytraceScene::build(&mut scene, &settings);
let rtc = RtCamera::new(&area_light_camera(), &settings);
let mut film = Film::new(24, 24);
gpu.render(&rt, &rtc, &settings, &mut film, 0, 16).unwrap();
let quick = film.resolve_hdr();
let mut sse = 0.0f64;
let mut mean = 0.0f64;
let mut n = 0usize;
for (a, b) in quick.chunks_exact(4).zip(reference.chunks_exact(4)) {
for k in 0..3 {
let d = (a[k] - b[k]) as f64;
sse += d * d;
mean += b[k] as f64;
n += 1;
}
}
let rms = (sse / n as f64).sqrt();
let mean = mean / n as f64;
assert!(mean > 0.05, "the scene is not lit ({mean})");
assert!(
rms < 0.048 * mean,
"16 GPU samples are {:.1}% off converged — the kernel's sampler is not stratified",
100.0 * rms / mean
);
}
#[test]
fn gpu_and_cpu_agree_on_the_denoiser_guides() {
let Some(mut gpu) = backend() else { return };
let mut scene = lit_box_scene();
let mut mirror = StandardMaterial::new(Color::new(0.9, 0.9, 0.95));
mirror.roughness = 0.03;
mirror.metalness = 1.0;
let mut ball = Object3D::mesh(Mesh::new(
SphereGeometry::new(0.9, 32, 24),
Material::Standard(mirror),
));
ball.position = Vector3::new(0.0, 0.9, 1.5);
scene.add(ball);
let settings = RaytraceSettings {
samples_per_pixel: 64,
max_bounces: 3,
adaptive_threshold: 0.0,
denoise: false,
..Default::default()
};
let rt = RaytraceScene::build(&mut scene, &settings);
let cam = RtCamera::new(&camera(), &settings);
let mut g = Film::new(32, 32);
gpu.render(&rt, &cam, &settings, &mut g, 0, 64).unwrap();
let mut c = Film::new(32, 32);
CpuBackend::new()
.render(&rt, &cam, &settings, &mut c, 0, 64)
.unwrap();
let (ga, ca) = (g.resolve_albedo(), c.resolve_albedo());
let mean =
|v: &[[f32; 3]]| v.iter().map(|p| p[0] as f64).sum::<f64>() / v.len().max(1) as f64;
let (gm, cm) = (mean(&ga), mean(&ca));
assert!(cm > 0.02, "the albedo guide is empty ({cm})");
assert!(
(gm - cm).abs() < 0.06 * cm,
"albedo guide: gpu {gm:.4} vs cpu {cm:.4}"
);
let (gn, cn) = (g.resolve_normal(), c.resolve_normal());
let mut worst = 0.0f32;
for (a, b) in gn.iter().zip(cn.iter()) {
let dot = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
let len_a = (a[0] * a[0] + a[1] * a[1] + a[2] * a[2]).sqrt();
let len_b = (b[0] * b[0] + b[1] * b[1] + b[2] * b[2]).sqrt();
if len_a > 0.1 && len_b > 0.1 {
worst = worst.max(1.0 - dot);
}
}
assert!(worst < 0.25, "normal guides diverge by {worst} (1 - cos)");
}
#[test]
fn the_renderer_drives_the_gpu_backend() {
let Some(gpu) = backend() else { return };
let mut scene = lit_box_scene();
let cam = camera();
let mut r = super::super::RaytraceRenderer::with_backend(32, 32, Box::new(gpu));
r.set_settings(
RaytraceSettings::default()
.with_samples(8)
.with_denoise(false),
);
assert_eq!(r.backend_name(), "gpu");
let rgba = r.render_to_rgba(&mut scene, &cam);
assert_eq!(rgba.len(), 32 * 32 * 4);
assert!(rgba.chunks_exact(4).any(|p| p[0] > 8), "image is black");
}
}