use super::fixtures::{final_only, read_stream_until_done, test_db, tiny_scene};
use crate::{render_core, serve::handle_connection};
use indicatrix_net::{
handshake,
messages::{Backend, ClientMessage, RenderRequest, StreamEvent, Welcome},
};
use std::{net::TcpListener, thread};
#[test]
fn serve_round_trip_over_a_loopback_socket_returns_a_correctly_sized_buffer() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
let server = thread::spawn(move || {
let (stream, _) = listener.accept().unwrap();
handle_connection(stream, 2, &test_db()).unwrap();
});
let mut client = std::net::TcpStream::connect(addr).unwrap();
indicatrix_net::messages::write_message(&mut client, &handshake::local_hello()).unwrap();
let welcome: Welcome = indicatrix_net::messages::read_message(&mut client).unwrap();
assert!(matches!(
welcome.render.as_ref().unwrap().backend,
Backend::Cpu { .. }
));
let scene = tiny_scene();
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 5,
scene,
first_sample: 10,
samples: 3,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut client,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let events = read_stream_until_done(&mut client);
let frames: Vec<_> = events
.iter()
.filter_map(|(e, p)| match e {
StreamEvent::Frame(h) => Some((h, p.as_ref().unwrap())),
_ => None,
})
.collect();
assert_eq!(frames.len(), 1);
let (header, payload) = frames[0];
assert_eq!(header.request_id, 5);
assert_eq!(header.first_sample, 10);
assert_eq!(header.samples, 3);
assert_eq!(
payload.len(),
4 * 4 * indicatrix_net::radiance::BYTES_PER_PIXEL
);
drop(client); server.join().unwrap();
}
#[test]
fn serve_round_trip_result_matches_tracing_the_same_range_directly() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
let scene = tiny_scene();
let scene_for_server = scene.clone();
let server = thread::spawn(move || {
let (stream, _) = listener.accept().unwrap();
handle_connection(stream, 2, &test_db()).unwrap();
});
let mut client = std::net::TcpStream::connect(addr).unwrap();
indicatrix_net::messages::write_message(&mut client, &handshake::local_hello()).unwrap();
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut client).unwrap();
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 6,
scene: scene.clone(),
first_sample: 0,
samples: 4,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut client,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let events = read_stream_until_done(&mut client);
let (_header, payload) = events
.iter()
.find_map(|(e, p)| match e {
StreamEvent::Frame(h) => Some((h, p.as_ref().unwrap())),
_ => None,
})
.unwrap();
drop(client);
server.join().unwrap();
let over_the_wire =
indicatrix_net::radiance::decode(payload, scene.width, scene.height).unwrap();
let direct = render_core::trace_samples(&scene_for_server, 0, 4, 2);
for (a, b) in over_the_wire.iter().zip(&direct) {
let diff = (*a - *b).abs();
let scale = a.abs().max(b.abs()).max(glam::Vec3::splat(1e-6));
assert!(
(diff / scale).max_element() < 1e-3,
"over_the_wire={a:?} direct={b:?}"
);
}
}
#[cfg(feature = "gpu")]
#[test]
fn serve_round_trip_over_gpu_reports_backend_gpu_and_a_correctly_sized_buffer() {
use crate::{cli::ComputeMode, serve::handle_connection_with_gpu};
use indicatrix::renderer::gpu_backend::GpuBackend;
use std::{net::TcpStream, sync::Arc};
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
let scene = tiny_scene();
let server = thread::spawn(move || {
let (stream, _) = listener.accept().unwrap();
let gpu = Arc::new(GpuBackend::acquire());
handle_connection_with_gpu(
stream,
2,
&gpu,
&test_db(),
ComputeMode::default(),
&indicatrix_net::messages::LOOPBACK_SERVER_PREFERENCE,
)
.unwrap();
});
let mut client = TcpStream::connect(addr).unwrap();
indicatrix_net::messages::write_message(&mut client, &handshake::local_hello()).unwrap();
let welcome: Welcome = indicatrix_net::messages::read_message(&mut client).unwrap();
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 7,
scene: scene.clone(),
first_sample: 0,
samples: 4,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut client,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let events = read_stream_until_done(&mut client);
let (header, payload) = events
.iter()
.find_map(|(e, p)| match e {
StreamEvent::Frame(h) => Some((h, p.as_ref().unwrap())),
_ => None,
})
.unwrap();
assert_eq!(header.samples, 4);
assert_eq!(
payload.len(),
scene.width as usize * scene.height as usize * indicatrix_net::radiance::BYTES_PER_PIXEL
);
drop(client);
server.join().unwrap();
if let Some(Backend::Gpu { adapter }) = welcome.render.map(|r| r.backend) {
assert!(!adapter.is_empty(), "adapter label must be non-empty");
}
}
#[cfg(feature = "gpu")]
#[test]
fn hybrid_gpu_and_cpu_split_sums_to_the_same_result_as_tracing_the_range_directly() {
use super::fixtures::tiny_scene_without_dispersion;
use crate::{cli::ComputeMode, serve::handle_connection_with_gpu};
use indicatrix::renderer::gpu_backend::GpuBackend;
use std::{net::TcpStream, sync::Arc};
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
let scene = tiny_scene_without_dispersion();
let scene_for_direct = scene.clone();
let server = thread::spawn(move || {
let (stream, _) = listener.accept().unwrap();
let gpu = Arc::new(GpuBackend::acquire());
handle_connection_with_gpu(
stream,
2,
&gpu,
&test_db(),
ComputeMode::Hybrid,
&indicatrix_net::messages::LOOPBACK_SERVER_PREFERENCE,
)
.unwrap();
});
let mut client = TcpStream::connect(addr).unwrap();
indicatrix_net::messages::write_message(&mut client, &handshake::local_hello()).unwrap();
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut client).unwrap();
let request = RenderRequest {
intent: indicatrix_net::messages::RequestIntent::Batch,
request_id: 8,
scene: scene.clone(),
first_sample: 0,
samples: 32,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut client,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let events = read_stream_until_done(&mut client);
let (header, payload) = events
.iter()
.find_map(|(e, p)| match e {
StreamEvent::Frame(h) => Some((h, p.as_ref().unwrap())),
_ => None,
})
.unwrap();
assert_eq!(header.samples, 32);
drop(client);
server.join().unwrap();
let over_the_wire =
indicatrix_net::radiance::decode(payload, scene.width, scene.height).unwrap();
let direct = render_core::trace_samples(&scene_for_direct, 0, 32, 2);
for (a, b) in over_the_wire.iter().zip(&direct) {
let diff = (*a - *b).abs();
let scale = a.abs().max(b.abs()).max(glam::Vec3::splat(1e-6));
let rel = (diff / scale).max_element();
assert!(rel < 1e-3, "over_the_wire={a:?} direct={b:?} rel={rel}");
}
}