use super::tracer::{SharedState, TracerJob, run_tracer};
use glam::Vec3;
use indicatrix::renderer::gpu_backend::GpuBackend;
use indicatrix_net::messages::{ErrorMsg, error_codes};
use std::sync::{
Arc, Mutex, PoisonError,
atomic::{AtomicBool, Ordering},
mpsc,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Output {
Radiance,
FinalImage(indicatrix::color::ColorSpace),
}
#[derive(Debug)]
pub enum ProducerOutcome {
Complete {
final_total: Option<Vec<Vec3>>,
reclaimed_samples: u32,
},
Cancelled,
Failed(ErrorMsg),
}
pub struct ProducerSink {
state: Arc<Mutex<SharedState>>,
cancel: Arc<AtomicBool>,
progress: mpsc::Sender<()>,
anchor: u32,
pixels: usize,
}
impl ProducerSink {
pub(super) const fn new(
state: Arc<Mutex<SharedState>>,
cancel: Arc<AtomicBool>,
progress: mpsc::Sender<()>,
anchor: u32,
pixels: usize,
) -> Self {
Self {
state,
cancel,
progress,
anchor,
pixels,
}
}
#[must_use]
pub fn is_cancelled(&self) -> bool {
self.cancel.load(Ordering::Relaxed)
}
pub fn add_chunk(&self, done: u32, sum: &[Vec3]) {
if done == 0 || sum.len() != self.pixels {
return;
}
let mut guard = self.state.lock().unwrap_or_else(PoisonError::into_inner);
guard.pending_delta.add_set(self.anchor, done, sum);
guard.samples_done += done;
drop(guard);
let _ = self.progress.send(());
}
pub fn finish(self, outcome: ProducerOutcome) {
let cancelled = self.is_cancelled();
let mut guard = self.state.lock().unwrap_or_else(PoisonError::into_inner);
match outcome {
ProducerOutcome::Complete {
final_total,
reclaimed_samples,
} => {
guard.final_total = final_total.filter(|t| t.len() == self.pixels);
guard.reclaimed_samples = reclaimed_samples;
}
ProducerOutcome::Cancelled if cancelled => {}
ProducerOutcome::Cancelled => {
guard.failed = Some(ErrorMsg {
code: error_codes::TRACE_PANIC,
message: "internal error: the request stopped before it completed".to_string(),
request_id: None,
});
}
ProducerOutcome::Failed(error) => guard.failed = Some(error),
}
guard.finished = true;
drop(guard);
let _ = self.progress.send(());
}
pub(super) fn run_tracer(self, job: &TracerJob, gpu: &GpuBackend) {
run_tracer(job, gpu, &self.state, &self.cancel, &self.progress);
}
}
pub fn local_tracer(
request: &indicatrix_net::messages::RenderRequest,
threads: usize,
gpu: &Arc<GpuBackend>,
compute_mode: crate::cli::ComputeMode,
) -> impl FnOnce(ProducerSink) + Send + 'static {
let job = TracerJob {
scene: request.scene.clone(),
first_sample: request.first_sample,
samples: request.samples,
threads,
compute_mode,
};
let gpu = Arc::clone(gpu);
move |sink| sink.run_tracer(&job, &gpu)
}
impl Drop for ProducerSink {
fn drop(&mut self) {
let mut guard = self.state.lock().unwrap_or_else(PoisonError::into_inner);
if !guard.finished {
guard.finished = true;
guard.panicked = true;
drop(guard);
let _ = self.progress.send(());
}
}
}