use super::fixtures::{
decode_events, decode_payload, render_request_with_preview, shared_state,
shared_state_with_pending_frame, stream_config_with_preview_at, tiny_scene,
};
use crate::{
render_core,
stream_emit::{
downsample::downsample_preview,
emitter::{EmitterAccum, emit_tick},
},
};
use glam::Vec3;
use indicatrix_net::messages::{RenderRequest, StreamEvent, TransferMode};
use std::sync::{Arc, Mutex};
#[test]
fn emit_tick_skips_the_preview_before_any_sample_has_landed() {
let scene = tiny_scene();
let pixel_count = scene.width as usize * scene.height as usize;
let request = render_request_with_preview(scene);
let state = Arc::new(Mutex::new(shared_state(pixel_count, 0)));
let mut emitter = EmitterAccum::new(pixel_count);
let mut emission_count: u32 = 0;
let mut out = Vec::new();
emit_tick(
&mut out,
&request,
&state,
&mut emitter,
&mut emission_count,
)
.unwrap();
let events = decode_events(&out);
assert!(
!events.iter().any(|e| matches!(e, StreamEvent::Preview(_))),
"must not emit a PREVIEW before samples_done > 0: {events:?}"
);
assert!(
events.iter().any(|e| matches!(e, StreamEvent::Progress(_))),
"PROGRESS must still be emitted at 0/N: {events:?}"
);
}
#[test]
fn emit_tick_resumes_the_preview_once_a_sample_has_landed() {
let scene = tiny_scene();
let pixel_count = scene.width as usize * scene.height as usize;
let request = render_request_with_preview(scene);
let state = Arc::new(Mutex::new(shared_state(pixel_count, 4)));
let mut emitter = EmitterAccum::from_running_total(vec![Vec3::ONE; pixel_count]);
let mut emission_count: u32 = 0;
let mut out = Vec::new();
emit_tick(
&mut out,
&request,
&state,
&mut emitter,
&mut emission_count,
)
.unwrap();
let events = decode_events(&out);
assert!(
events.iter().any(|e| matches!(e, StreamEvent::Preview(_))),
"PREVIEW must resume once samples_done > 0: {events:?}"
);
}
#[test]
fn emit_tick_skips_a_full_scale_preview_when_a_frame_delta_is_also_sent() {
let scene = tiny_scene();
let pixel_count = scene.width as usize * scene.height as usize;
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 1,
scene: scene.clone(),
first_sample: 0,
samples: 8,
stream: stream_config_with_preview_at(
TransferMode::LiveProgressive,
scene.width,
scene.height,
),
};
let state = Arc::new(Mutex::new(shared_state_with_pending_frame(
pixel_count,
4,
&vec![Vec3::ONE; pixel_count],
)));
let mut emitter = EmitterAccum::new(pixel_count);
let mut emission_count: u32 = 0;
let mut out = Vec::new();
emit_tick(
&mut out,
&request,
&state,
&mut emitter,
&mut emission_count,
)
.unwrap();
let events = decode_events(&out);
assert!(
events.iter().any(|e| matches!(e, StreamEvent::Frame(_))),
"expected a FRAME delta: {events:?}"
);
assert!(
!events.iter().any(|e| matches!(e, StreamEvent::Preview(_))),
"a full-scale PREVIEW alongside a FRAME delta is redundant and must be skipped: {events:?}"
);
assert!(
events.iter().any(|e| matches!(e, StreamEvent::Progress(_))),
"PROGRESS must still be emitted: {events:?}"
);
}
#[test]
fn emit_tick_still_sends_a_full_scale_preview_under_final_only() {
let scene = tiny_scene();
let pixel_count = scene.width as usize * scene.height as usize;
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 1,
scene: scene.clone(),
first_sample: 0,
samples: 8,
stream: stream_config_with_preview_at(TransferMode::FinalOnly, scene.width, scene.height),
};
let state = Arc::new(Mutex::new(shared_state(pixel_count, 4)));
let mut emitter = EmitterAccum::from_running_total(vec![Vec3::ONE; pixel_count]);
let mut emission_count: u32 = 0;
let mut out = Vec::new();
emit_tick(
&mut out,
&request,
&state,
&mut emitter,
&mut emission_count,
)
.unwrap();
let events = decode_events(&out);
assert!(
!events.iter().any(|e| matches!(e, StreamEvent::Frame(_))),
"FinalOnly must never send a FRAME from emit_tick: {events:?}"
);
assert!(
events.iter().any(|e| matches!(e, StreamEvent::Preview(_))),
"a full-scale PREVIEW is still the only progressive image under FinalOnly and must \
not be skipped: {events:?}"
);
}
#[test]
fn emit_tick_still_sends_a_downscaled_preview_alongside_a_frame_delta() {
let scene = tiny_scene();
let pixel_count = scene.width as usize * scene.height as usize;
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 1,
scene,
first_sample: 0,
samples: 8,
stream: stream_config_with_preview_at(TransferMode::LiveProgressive, 2, 2),
};
let state = Arc::new(Mutex::new(shared_state_with_pending_frame(
pixel_count,
4,
&vec![Vec3::ONE; pixel_count],
)));
let mut emitter = EmitterAccum::new(pixel_count);
let mut emission_count: u32 = 0;
let mut out = Vec::new();
emit_tick(
&mut out,
&request,
&state,
&mut emitter,
&mut emission_count,
)
.unwrap();
let events = decode_events(&out);
assert!(events.iter().any(|e| matches!(e, StreamEvent::Frame(_))));
assert!(
events.iter().any(|e| matches!(e, StreamEvent::Preview(_))),
"a downscaled PREVIEW must never be skipped: {events:?}"
);
}
#[test]
fn emit_tick_frame_delta_equals_exactly_what_the_tracer_had_pending() {
let scene = tiny_scene();
let pixel_count = scene.width as usize * scene.height as usize;
let contribution = render_core::trace_samples(&scene, 0, 4, 1);
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 7,
scene: scene.clone(),
first_sample: 0,
samples: 8,
stream: stream_config_with_preview_at(TransferMode::LiveProgressive, 2, 2),
};
let state = Arc::new(Mutex::new(shared_state_with_pending_frame(
pixel_count,
4,
&contribution,
)));
let mut emitter = EmitterAccum::new(pixel_count);
let mut emission_count: u32 = 0;
let mut out = Vec::new();
emit_tick(
&mut out,
&request,
&state,
&mut emitter,
&mut emission_count,
)
.unwrap();
let frame = decode_payload(&out, scene.width, scene.height, |e| {
matches!(e, StreamEvent::Frame(_))
});
assert_eq!(
frame, contribution,
"the FRAME delta must equal exactly what the tracer had folded into pending_delta"
);
}
#[test]
fn emit_tick_preview_equals_the_downscaled_cumulative_sum() {
let scene = tiny_scene();
let pixel_count = scene.width as usize * scene.height as usize;
let contribution = render_core::trace_samples(&scene, 0, 4, 1);
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 8,
scene: scene.clone(),
first_sample: 0,
samples: 8,
stream: stream_config_with_preview_at(TransferMode::LiveProgressive, 2, 2),
};
let state = Arc::new(Mutex::new(shared_state_with_pending_frame(
pixel_count,
4,
&contribution,
)));
let mut emitter = EmitterAccum::new(pixel_count);
let mut emission_count: u32 = 0;
let mut out = Vec::new();
emit_tick(
&mut out,
&request,
&state,
&mut emitter,
&mut emission_count,
)
.unwrap();
let preview = decode_payload(&out, 2, 2, |e| matches!(e, StreamEvent::Preview(_)));
let expected = downsample_preview(&contribution, scene.width, scene.height, 2, 2);
assert_eq!(
preview, expected,
"PREVIEW must equal the downscaled cumulative running total"
);
}
#[test]
fn emit_tick_swap_leaves_the_emitter_copy_independent_of_the_shared_pending_delta() {
let scene = tiny_scene();
let pixel_count = scene.width as usize * scene.height as usize;
let first = render_core::trace_samples(&scene, 0, 4, 1);
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 9,
scene: scene.clone(),
first_sample: 0,
samples: 8,
stream: stream_config_with_preview_at(TransferMode::LiveProgressive, 2, 2),
};
let state = Arc::new(Mutex::new(shared_state_with_pending_frame(
pixel_count,
4,
&first,
)));
let mut emitter = EmitterAccum::new(pixel_count);
let mut emission_count: u32 = 0;
let mut out = Vec::new();
emit_tick(
&mut out,
&request,
&state,
&mut emitter,
&mut emission_count,
)
.unwrap();
let second = render_core::trace_samples(&scene, 4, 4, 1);
{
let mut guard = state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
guard.pending_delta.add(4, 4, &second);
}
let frame = decode_payload(&out, scene.width, scene.height, |e| {
matches!(e, StreamEvent::Frame(_))
});
assert_eq!(
frame, first,
"the FRAME already written must be unaffected by data added to pending_delta \
after the swap that produced it"
);
assert_eq!(
emitter.running_total(),
&first[..],
"EmitterAccum::running_total must be genuinely separate memory from \
state.pending_delta's buffer, not an alias of it"
);
}
#[test]
fn emit_tick_preview_is_gated_by_one_percent_of_the_sample_budget_since_the_last_one() {
let scene = tiny_scene();
let pixel_count = scene.width as usize * scene.height as usize;
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 1,
scene,
first_sample: 0,
samples: 200, stream: stream_config_with_preview_at(TransferMode::FinalOnly, 2, 2),
};
let state = Arc::new(Mutex::new(shared_state(pixel_count, 4)));
let mut emitter = EmitterAccum::from_running_total(vec![Vec3::ONE; pixel_count]);
let mut emission_count: u32 = 0;
let mut out = Vec::new();
emit_tick(
&mut out,
&request,
&state,
&mut emitter,
&mut emission_count,
)
.unwrap();
assert!(
decode_events(&out)
.iter()
.any(|e| matches!(e, StreamEvent::Preview(_))),
"the first preview opportunity must always qualify"
);
state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.samples_done = 5;
let mut out = Vec::new();
emit_tick(
&mut out,
&request,
&state,
&mut emitter,
&mut emission_count,
)
.unwrap();
assert!(
!decode_events(&out)
.iter()
.any(|e| matches!(e, StreamEvent::Preview(_))),
"a preview that has not advanced by 1% of the sample budget must be suppressed"
);
state
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.samples_done = 6;
let mut out = Vec::new();
emit_tick(
&mut out,
&request,
&state,
&mut emitter,
&mut emission_count,
)
.unwrap();
assert!(
decode_events(&out)
.iter()
.any(|e| matches!(e, StreamEvent::Preview(_))),
"a preview that has advanced by 1% since the last one must resume"
);
}