use super::{
super::tracer::SharedState,
display::{DisplayDenoiser, DisplayUpdate},
};
use glam::Vec3;
use indicatrix_net::{
SceneState,
messages::{NetError, adaptive::PeerLink},
radiance::{self, EncodedPayload},
};
use std::sync::{Arc, Mutex};
pub(in crate::stream_emit) struct PendingDelta {
buffer: Vec<Vec3>,
range: Option<(u32, u32)>,
}
impl PendingDelta {
pub(in crate::stream_emit) fn new(pixel_count: usize) -> Self {
Self {
buffer: vec![Vec3::ZERO; pixel_count],
range: None,
}
}
pub(in crate::stream_emit) fn add(
&mut self,
first_sample: u32,
samples: u32,
contribution: &[Vec3],
) {
debug_assert_eq!(contribution.len(), self.buffer.len());
match self.range {
None => {
self.buffer.copy_from_slice(contribution);
self.range = Some((first_sample, samples));
}
Some((range_first, range_samples)) => {
debug_assert_eq!(
first_sample,
range_first + range_samples,
"sub-batches must coalesce in contiguous sample order"
);
for (acc, c) in self.buffer.iter_mut().zip(contribution) {
*acc += *c;
}
self.range = Some((range_first, range_samples + samples));
}
}
}
pub(in crate::stream_emit) fn add_set(
&mut self,
anchor: u32,
samples: u32,
contribution: &[Vec3],
) {
debug_assert_eq!(contribution.len(), self.buffer.len());
match self.range {
None => {
self.buffer.copy_from_slice(contribution);
self.range = Some((anchor, samples));
}
Some((range_first, range_samples)) => {
for (acc, c) in self.buffer.iter_mut().zip(contribution) {
*acc += *c;
}
self.range = Some((range_first, range_samples + samples));
}
}
}
pub(in crate::stream_emit) fn swap_with(
&mut self,
spare: &mut Vec<Vec3>,
) -> Option<(u32, u32)> {
debug_assert_eq!(
spare.len(),
self.buffer.len(),
"swap_with's spare buffer must match this delta's pixel count"
);
std::mem::swap(&mut self.buffer, spare);
self.range.take()
}
}
pub(in crate::stream_emit) struct EmitterAccum {
running_total: Vec<Vec3>,
spare: Vec<Vec3>,
link: Arc<PeerLink>,
display: Option<DisplayDenoiser>,
last_preview_samples_done: Option<u32>,
}
impl EmitterAccum {
#[cfg(test)]
pub(in crate::stream_emit) fn new(pixel_count: usize) -> Self {
Self::with_link(
pixel_count,
Arc::new(PeerLink::fixed(
indicatrix_net::messages::PayloadEncoding::Raw,
)),
)
}
pub(in crate::stream_emit) fn with_link(pixel_count: usize, link: Arc<PeerLink>) -> Self {
Self {
running_total: vec![Vec3::ZERO; pixel_count],
spare: vec![Vec3::ZERO; pixel_count],
link,
display: None,
last_preview_samples_done: None,
}
}
#[cfg(test)]
pub(in crate::stream_emit) fn from_running_total(running_total: Vec<Vec3>) -> Self {
let spare = vec![Vec3::ZERO; running_total.len()];
Self {
running_total,
spare,
link: Arc::new(PeerLink::fixed(
indicatrix_net::messages::PayloadEncoding::Raw,
)),
display: None,
last_preview_samples_done: None,
}
}
pub(in crate::stream_emit) fn send_delta(
&self,
write: impl FnOnce(&EncodedPayload<'_>) -> Result<(), NetError>,
) -> Result<(), NetError> {
self.link
.send_payload(radiance::as_bytes(&self.spare), write)
}
pub(in crate::stream_emit) fn send_running_total(
&self,
write: impl FnOnce(&EncodedPayload<'_>) -> Result<(), NetError>,
) -> Result<(), NetError> {
self.link
.send_payload(radiance::as_bytes(&self.running_total), write)
}
pub(in crate::stream_emit) fn send_other(
&self,
buffer: &[Vec3],
write: impl FnOnce(&EncodedPayload<'_>) -> Result<(), NetError>,
) -> Result<(), NetError> {
self.link.send_payload(radiance::as_bytes(buffer), write)
}
pub(in crate::stream_emit) fn link(&self) -> &PeerLink {
&self.link
}
pub(in crate::stream_emit) fn swap_and_fold(
&mut self,
state: &Mutex<SharedState>,
) -> (Option<(u32, u32)>, u32) {
let (range, samples_done) = {
let mut guard = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let range = guard.pending_delta.swap_with(&mut self.spare);
(range, guard.samples_done)
};
if range.is_some() {
for (total, c) in self.running_total.iter_mut().zip(self.spare.iter()) {
*total += *c;
}
}
(range, samples_done)
}
pub(in crate::stream_emit) fn running_total(&self) -> &[Vec3] {
&self.running_total
}
#[must_use]
pub(in crate::stream_emit) fn preview_due(
&self,
samples_done: u32,
sample_budget: u32,
) -> bool {
self.last_preview_samples_done.is_none_or(|last| {
let threshold = (sample_budget / 100).max(1);
samples_done.saturating_sub(last) >= threshold
})
}
pub(in crate::stream_emit) const fn record_preview_sent(&mut self, samples_done: u32) {
self.last_preview_samples_done = Some(samples_done);
}
pub(in crate::stream_emit) fn display_tick(
&mut self,
scene: &SceneState,
fresh: bool,
samples_done: u32,
) -> DisplayUpdate {
self.display
.get_or_insert_with(|| DisplayDenoiser::spawn(scene))
.tick(fresh, samples_done, &self.running_total)
}
pub(in crate::stream_emit) const fn take_display(&mut self) -> Option<DisplayDenoiser> {
self.display.take()
}
}