use glam::Vec3;
use indicatrix::optics::raytracer::{
Camera, EnvironmentSource, FacetFinish, build_plane_soa, pixel_rotations, sample_draws,
trace_spectral_ray_with_finish_soa,
};
use indicatrix_net::SceneState;
use std::{
sync::{
Condvar, LazyLock, Mutex,
atomic::{AtomicBool, AtomicUsize, Ordering},
},
thread,
};
use indicatrix::renderer::gpu_backend::{GpuAccumulate, GpuBackend, GpuSceneRef};
pub(crate) mod hybrid;
#[must_use]
fn resolve_facet_finishes(scene: &SceneState) -> Vec<FacetFinish> {
if scene.girdle_frosted {
indicatrix::geometry::girdle_facet_finishes(&scene.planes)
} else {
Vec::new()
}
}
const VIEWER_FOV_DEG: f32 = 42.0;
#[must_use]
pub fn effective_thread_count(threads: usize) -> usize {
if threads == 0 {
thread::available_parallelism().map_or(8, std::num::NonZero::get)
} else {
threads
}
}
struct ThreadPermits {
capacity: usize,
available: Mutex<usize>,
freed: Condvar,
}
impl ThreadPermits {
fn new(capacity: usize) -> Self {
Self {
capacity: capacity.max(1),
available: Mutex::new(capacity.max(1)),
freed: Condvar::new(),
}
}
fn acquire(&self, wanted: usize) -> usize {
let wanted = wanted.clamp(1, self.capacity);
let mut available = self
.available
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
while *available < wanted {
available = self
.freed
.wait(available)
.unwrap_or_else(std::sync::PoisonError::into_inner);
}
*available -= wanted;
wanted
}
fn release(&self, held: usize) {
let mut available = self
.available
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
*available += held;
drop(available);
self.freed.notify_all();
}
}
static THREAD_PERMITS: LazyLock<ThreadPermits> =
LazyLock::new(|| ThreadPermits::new(effective_thread_count(0)));
struct PermitGuard(usize);
impl Drop for PermitGuard {
fn drop(&mut self) {
THREAD_PERMITS.release(self.0);
}
}
#[must_use]
pub fn trace_samples(
scene: &SceneState,
first_sample: u32,
samples: u32,
threads: usize,
) -> Vec<Vec3> {
let width = scene.width;
let height = scene.height;
let mut buffer = vec![Vec3::ZERO; width as usize * height as usize];
if samples == 0 || width == 0 || height == 0 {
return buffer;
}
let camera = Camera::new(scene.yaw, scene.pitch, scene.distance, VIEWER_FOV_DEG);
let environment =
scene
.lighting_preset
.studio(scene.exposure, scene.light_yaw, scene.light_pitch);
trace_into(
scene,
first_sample,
samples,
threads,
&camera,
environment,
&mut buffer,
);
buffer
}
#[must_use]
pub fn trace_samples_with_gpu(
gpu: &GpuBackend,
scene: &SceneState,
first_sample: u32,
samples: u32,
threads: usize,
) -> Vec<Vec3> {
let never_cancel = AtomicBool::new(false);
trace_samples_with_gpu_cancellable(gpu, scene, first_sample, samples, threads, &never_cancel)
.expect("cancel is never set, so this dispatch can never observe GpuAccumulate::Cancelled")
}
#[must_use]
pub fn trace_samples_with_gpu_cancellable(
gpu: &GpuBackend,
scene: &SceneState,
first_sample: u32,
samples: u32,
threads: usize,
cancel: &AtomicBool,
) -> Option<Vec<Vec3>> {
let width = scene.width;
let height = scene.height;
let mut buffer = vec![Vec3::ZERO; width as usize * height as usize];
if samples == 0 || width == 0 || height == 0 {
return Some(buffer);
}
let camera = Camera::new(scene.yaw, scene.pitch, scene.distance, VIEWER_FOV_DEG);
let environment =
scene
.lighting_preset
.studio(scene.exposure, scene.light_yaw, scene.light_pitch);
let facet_finishes = resolve_facet_finishes(scene);
let gpu_scene = GpuSceneRef {
camera: &camera,
width,
height,
planes: &scene.planes,
facet_finishes: &facet_finishes,
material: &scene.material,
max_bounces: scene.max_bounces,
environment,
};
match gpu.try_accumulate_cancellable(&gpu_scene, first_sample, samples, &mut buffer, cancel) {
GpuAccumulate::Done => return Some(buffer),
GpuAccumulate::Cancelled => return None,
GpuAccumulate::Declined => {}
}
trace_into(
scene,
first_sample,
samples,
threads,
&camera,
environment,
&mut buffer,
);
Some(buffer)
}
fn trace_into(
scene: &SceneState,
first_sample: u32,
samples: u32,
threads: usize,
camera: &Camera,
environment: EnvironmentSource<'_>,
buffer: &mut [Vec3],
) {
let width = scene.width;
let height = scene.height;
let width_usize = width as usize;
let requested_threads = effective_thread_count(threads).max(1);
let num_threads = THREAD_PERMITS.acquire(requested_threads);
let _permits = PermitGuard(num_threads);
let planes = &scene.planes;
let material = &scene.material;
let max_bounces = scene.max_bounces;
let facet_finishes = resolve_facet_finishes(scene);
let facet_finishes = facet_finishes.as_slice();
let plane_soa = build_plane_soa(planes);
let rows: Vec<Option<&mut [Vec3]>> = buffer.chunks_mut(width_usize).map(Some).collect();
let rows = Mutex::new(rows);
let next_row = AtomicUsize::new(0);
thread::scope(|s| {
for _ in 0..num_threads {
let rows = &rows;
let next_row = &next_row;
let plane_soa = &plane_soa;
s.spawn(move || {
loop {
let y = next_row.fetch_add(1, Ordering::Relaxed);
if y >= height as usize {
break;
}
let row = rows
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)[y]
.take()
.expect("each row index is claimed by exactly one thread via fetch_add");
for (x, pixel) in row.iter_mut().enumerate() {
let global_pixel_idx = (y * width_usize + x) as u32;
let mut sample_sum = Vec3::ZERO;
let rot = pixel_rotations(global_pixel_idx);
for s_idx in 0..samples {
let sample_num = first_sample.wrapping_add(s_idx);
let draws = sample_draws(global_pixel_idx, sample_num, &rot);
let ray = camera.generate_ray(
x as f32,
y as f32,
width as f32,
height as f32,
draws.jitter_x,
draws.jitter_y,
);
sample_sum += trace_spectral_ray_with_finish_soa(
ray,
planes,
plane_soa,
facet_finishes,
material,
max_bounces,
environment,
draws.seed,
draws.hero_rand,
None,
);
}
*pixel += sample_sum;
}
}
});
}
});
}
#[cfg(test)]
mod tests {
use super::*;
use indicatrix::{
geometry::cuts::StandardGemCuts,
optics::{materials::GemMaterial, raytracer::LightingPreset},
};
fn tiny_scene() -> SceneState {
SceneState {
width: 8,
height: 8,
yaw: 0.4,
pitch: 0.3,
distance: 3.0,
light_yaw: 0.85,
light_pitch: 0.95,
exposure: 1.0,
max_bounces: 4,
lighting_preset: LightingPreset::Daylight,
material: GemMaterial::diamond(),
planes: StandardGemCuts::standard_round_brilliant(),
girdle_frosted: false,
}
}
#[test]
#[ignore = "manual probe: reports whether this machine has a usable wgpu adapter"]
fn probe_gpu_adapter() {
let backend = GpuBackend::acquire();
match backend.adapter_label() {
Some(label) => eprintln!("GPU ADAPTER FOUND: {label}"),
None => eprintln!("NO GPU ADAPTER (declined)"),
}
}
#[test]
fn returns_a_buffer_sized_to_the_scene() {
let scene = tiny_scene();
let buf = trace_samples(&scene, 0, 4, 1);
assert_eq!(buf.len(), 64);
}
#[test]
fn zero_samples_returns_an_all_zero_buffer_of_the_right_size() {
let scene = tiny_scene();
let buf = trace_samples(&scene, 0, 0, 1);
assert_eq!(buf.len(), 64);
assert!(buf.iter().all(|v| *v == Vec3::ZERO));
}
#[test]
fn single_and_multi_threaded_traces_agree() {
let scene = tiny_scene();
let single = trace_samples(&scene, 0, 4, 1);
let multi = trace_samples(&scene, 0, 4, 4);
for (a, b) in single.iter().zip(multi.iter()) {
assert_eq!(a, b);
}
}
#[test]
fn splitting_a_sample_range_across_two_calls_sums_to_the_same_result_as_one_call() {
let scene = tiny_scene();
let whole = trace_samples(&scene, 0, 8, 2);
let first_half = trace_samples(&scene, 0, 4, 2);
let second_half = trace_samples(&scene, 4, 4, 2);
for i in 0..whole.len() {
let split_sum = first_half[i] + second_half[i];
let diff = (whole[i] - split_sum).abs();
let scale = whole[i].abs().max(split_sum.abs()).max(Vec3::splat(1e-6));
let rel = diff / scale;
assert!(
rel.max_element() < 1e-3,
"pixel {i}: whole={:?} split_sum={:?} rel={:?}",
whole[i],
split_sum,
rel
);
}
}
}