use super::*;
#[test]
fn the_short_side_of_a_grid_is_the_resolution() {
assert_eq!(grid_size(128, 1920, 1080), (228, 128));
assert_eq!(grid_size(128, 1080, 1920), (128, 228));
assert_eq!(grid_size(128, 512, 512), (128, 128));
let (w, h) = grid_size(128, 0, 0);
assert!(w >= 1 && h >= 1);
}
#[test]
fn the_hue_wheel_is_fully_saturated_everywhere() {
for i in 0..60 {
let h = i as f32 / 60.0;
let c = hsv_to_rgb(h, 1.0, 1.0);
let max = c.iter().copied().fold(f32::MIN, f32::max);
let min = c.iter().copied().fold(f32::MAX, f32::min);
assert!((max - 1.0).abs() < 1e-5, "hue {h}: max {max}");
assert!(min.abs() < 1e-5, "hue {h}: min {min}");
}
assert_eq!(hsv_to_rgb(1.0, 1.0, 1.0), hsv_to_rgb(0.0, 1.0, 1.0));
}
#[test]
fn the_generator_repeats_from_a_seed_and_stays_in_range() {
let draw = || {
let mut rng = Rng::new(7);
(0..512).map(|_| rng.next_f32()).collect::<Vec<_>>()
};
assert_eq!(draw(), draw(), "same seed, different numbers");
let xs = draw();
assert!(xs.iter().all(|x| (0.0..1.0).contains(x)));
let mean = xs.iter().sum::<f32>() / xs.len() as f32;
assert!((mean - 0.5).abs() < 0.05, "mean {mean}");
}
#[test]
fn quality_levels_only_go_up() {
let mut last: Option<&FluidQuality> = None;
for q in QUALITY_LEVELS {
if let Some(prev) = last {
assert!(
q.sim_resolution > prev.sim_resolution,
"{} vs {}",
q.name,
prev.name
);
assert!(
q.dye_resolution > prev.dye_resolution,
"{} vs {}",
q.name,
prev.name
);
assert!(
q.pressure_iterations > prev.pressure_iterations,
"{}",
q.name
);
assert!(q.bloom_iterations >= prev.bloom_iterations, "{}", q.name);
}
last = Some(q);
}
let high = quality("high").expect("a level called high");
let default = FluidConfig::default();
assert_eq!(default.sim_resolution, high.sim_resolution);
assert_eq!(default.dye_resolution, high.dye_resolution);
assert_eq!(default.pressure_iterations, high.pressure_iterations);
assert_eq!(default.bloom_resolution, high.bloom_resolution);
assert_eq!(default.sunrays_resolution, high.sunrays_resolution);
assert_eq!(FluidConfig::default().with_quality(high), default);
assert!(quality("enormous").is_none());
assert_eq!(quality_names().count(), QUALITY_LEVELS.len());
}
#[test]
fn an_oversized_grid_is_scaled_down_whole() {
let (w, h) = grid_size_limited(4096, 3840, 1080, 8192);
assert!(w <= 8192 && h <= 8192, "{w}x{h} is over the limit");
let asked = grid_size(4096, 3840, 1080);
let aspect_asked = asked.0 as f32 / asked.1 as f32;
let aspect_got = w as f32 / h as f32;
assert!(
(aspect_asked - aspect_got).abs() < 0.01,
"the clamp changed the shape: {aspect_asked} -> {aspect_got}"
);
assert_eq!(
grid_size_limited(128, 1920, 1080, 8192),
grid_size(128, 1920, 1080)
);
let (w, h) = grid_size_limited(4096, 3840, 1080, 4);
assert!(w >= 1 && h >= 1 && w <= 4 && h <= 4, "{w}x{h}");
}
fn device() -> Option<(Arc<wgpu::Device>, Arc<wgpu::Queue>, FluidFormats)> {
let gpu = crate::gpu::testing::context("fluid")?;
let formats = FluidFormats::for_adapter(&gpu.adapter)?;
Some((gpu.device.clone(), gpu.queue.clone(), formats))
}
fn sim(width: u32, height: u32, config: FluidConfig) -> Option<FluidSim> {
let (device, queue, formats) = device()?;
FluidSim::with_formats(device, queue, width, height, config, formats).ok()
}
fn read_channel(sim: &FluidSim, fbo: &Fbo, channel: usize) -> Vec<f32> {
crate::renderer::readback::texture_channel_f32(&sim.device, &sim.queue, &fbo.texture, channel)
}
fn divergence_now(sim: &mut FluidSim) -> f32 {
let mut enc = sim.encoder("test divergence");
sim.record_divergence(&mut enc);
sim.queue.submit([enc.finish()]);
mean_abs(&read_channel(sim, &sim.divergence, 0))
}
fn mean_abs(xs: &[f32]) -> f32 {
xs.iter().map(|x| x.abs()).sum::<f32>() / xs.len() as f32
}
fn brightest(rgba: &[u8], width: u32, height: u32) -> (f32, f32, u8) {
let mut best = (0u32, 0u32, 0u8);
for y in 0..height {
for x in 0..width {
let at = ((y * width + x) * 4) as usize;
let v = rgba[at].max(rgba[at + 1]).max(rgba[at + 2]);
if v > best.2 {
best = (x, y, v);
}
}
}
(
best.0 as f32 / width as f32,
best.1 as f32 / height as f32,
best.2,
)
}
#[test]
fn a_splat_lands_where_it_was_asked_for() {
let config = FluidConfig {
bloom: false,
sunrays: false,
shading: false,
..FluidConfig::default()
};
let Some(mut sim) = sim(256, 256, config) else {
eprintln!("skipping: no GPU adapter");
return;
};
sim.splat(0.25, 0.25, 0.0, 0.0, [0.6, 0.6, 0.6]);
sim.update(1.0 / 60.0);
let rgba = sim.capture_rgba(256, 256);
let (x, y, v) = brightest(&rgba, 256, 256);
assert!(v > 32, "nothing was drawn (brightest {v})");
assert!((x - 0.25).abs() < 0.05, "x {x}");
assert!((y - 0.25).abs() < 0.05, "y {y}");
}
#[test]
fn projection_removes_the_divergence_a_splat_creates() {
let residual = |config: FluidConfig| -> Option<f32> {
let mut sim = sim(256, 256, config)?;
sim.splat(0.5, 0.5, 400.0, 0.0, [0.3, 0.3, 0.3]);
let raw = divergence_now(&mut sim);
assert!(
raw > 1e-4,
"the splat produced no divergence to remove: {raw}"
);
sim.step(1.0 / 6000.0);
Some(divergence_now(&mut sim) / raw)
};
let shipped = FluidConfig {
curl: 0.0,
..FluidConfig::default()
};
let converged = FluidConfig {
pressure_iterations: 320,
gradient_scale: 0.5,
..shipped
};
let (Some(shipped), Some(converged)) = (residual(shipped), residual(converged)) else {
eprintln!("skipping: no GPU adapter");
return;
};
assert!(
shipped < 0.75,
"the default projection left {shipped:.3} of the divergence"
);
assert!(
converged < 0.45,
"a converged projection left {converged:.3} of the divergence"
);
}
#[test]
fn the_missing_half_compensates_for_an_unconverged_solve() {
let residual = |iterations: u32, scale: f32| -> Option<f32> {
let mut sim = sim(
256,
256,
FluidConfig {
pressure_iterations: iterations,
gradient_scale: scale,
curl: 0.0,
..FluidConfig::default()
},
)?;
sim.splat(0.5, 0.5, 400.0, 0.0, [0.3, 0.3, 0.3]);
let raw = divergence_now(&mut sim);
sim.step(1.0 / 6000.0);
Some(divergence_now(&mut sim) / raw)
};
let (Some(few_half), Some(few_whole), Some(many_half), Some(many_whole)) = (
residual(20, 0.5),
residual(20, 1.0),
residual(320, 0.5),
residual(320, 1.0),
) else {
eprintln!("skipping: no GPU adapter");
return;
};
eprintln!(" 20 sweeps: 0.5 -> {few_half:.3}, 1.0 -> {few_whole:.3}");
eprintln!(" 320 sweeps: 0.5 -> {many_half:.3}, 1.0 -> {many_whole:.3}");
assert!(
few_whole < few_half,
"at 20 sweeps the overshoot was expected to help: 1.0 left {few_whole:.3}, 0.5 left {few_half:.3}"
);
assert!(
many_half < many_whole,
"at 320 sweeps the consistent coefficient was expected to win: 0.5 left {many_half:.3}, 1.0 left {many_whole:.3}"
);
assert!(
many_whole > 1.0,
"at 320 sweeps the overshoot was expected to add divergence, but left {many_whole:.3}"
);
}
#[test]
fn more_sweeps_leave_less_divergence() {
let run = |iterations: u32| -> Option<f32> {
let mut sim = sim(
256,
256,
FluidConfig {
pressure_iterations: iterations,
gradient_scale: 0.5,
curl: 0.0,
..FluidConfig::default()
},
)?;
sim.splat(0.5, 0.5, 400.0, 0.0, [0.3, 0.3, 0.3]);
sim.step(1.0 / 6000.0);
Some(divergence_now(&mut sim))
};
let (Some(few), Some(many)) = (run(1), run(80)) else {
eprintln!("skipping: no GPU adapter");
return;
};
assert!(
many < few,
"80 sweeps ({many:e}) did not beat 1 sweep ({few:e})"
);
}
#[test]
fn dye_fades_by_elapsed_time_not_by_frame_count() {
let total = |steps: u32, dt: f32| -> Option<f32> {
let mut sim = sim(
256,
256,
FluidConfig {
curl: 0.0,
density_dissipation: 1.0,
..FluidConfig::default()
},
)?;
sim.splat(0.5, 0.5, 0.0, 0.0, [0.5, 0.5, 0.5]);
for _ in 0..steps {
sim.step(dt);
}
let dye = read_channel(&sim, &sim.dye.read, 0);
Some(dye.iter().sum::<f32>())
};
let (Some(fast), Some(slow), Some(none)) =
(total(60, 1.0 / 60.0), total(20, 1.0 / 20.0), total(0, 0.0))
else {
eprintln!("skipping: no GPU adapter");
return;
};
assert!(none > 0.0, "no dye was splatted");
assert!(fast < none * 0.75, "a second of dissipation did nothing");
let ratio = fast / slow;
assert!(
(0.8..1.25).contains(&ratio),
"60 small steps and 20 large ones disagree by {ratio:.2}x"
);
}
#[test]
fn a_hard_driven_field_stays_finite() {
let Some(mut sim) = sim(
512,
256,
FluidConfig {
curl: 50.0,
velocity_dissipation: 0.0,
density_dissipation: 0.0,
sim_resolution: 64,
..FluidConfig::default()
},
) else {
eprintln!("skipping: no GPU adapter");
return;
};
for i in 0..40 {
let t = i as f32 / 40.0;
sim.splat(t, 1.0 - t, 3000.0, -3000.0, [1.0, 1.0, 1.0]);
sim.update(1.0 / 60.0);
}
for _ in 0..200 {
sim.update(1.0 / 60.0);
}
for channel in 0..2 {
let v = read_channel(&sim, &sim.velocity.read, channel);
assert!(
v.iter().all(|x| x.is_finite()),
"velocity channel {channel} went non-finite"
);
let worst = v.iter().copied().fold(0.0f32, |a, b| a.max(b.abs()));
assert!(worst <= 1001.0, "velocity reached {worst}");
}
let dye = read_channel(&sim, &sim.dye.read, 0);
assert!(dye.iter().all(|x| x.is_finite()), "dye went non-finite");
}
#[test]
fn the_same_seed_renders_the_same_frame() {
let run = || -> Option<Vec<u8>> {
let mut sim = sim(192, 128, FluidConfig::default())?;
sim.multiple_splats(12);
for _ in 0..30 {
sim.update(1.0 / 60.0);
}
Some(sim.capture_rgba(192, 128))
};
let (Some(a), Some(b)) = (run(), run()) else {
eprintln!("skipping: no GPU adapter");
return;
};
assert_eq!(a, b, "two runs of the same seed differ");
let Some(mut other) = sim(
192,
128,
FluidConfig {
seed: 99,
..FluidConfig::default()
},
) else {
return;
};
other.multiple_splats(12);
for _ in 0..30 {
other.update(1.0 / 60.0);
}
assert_ne!(a, other.capture_rgba(192, 128), "the seed changed nothing");
}
#[test]
fn a_resize_keeps_the_fluid() {
let Some(mut sim) = sim(256, 256, FluidConfig::default()) else {
eprintln!("skipping: no GPU adapter");
return;
};
sim.splat(0.5, 0.5, 0.0, 0.0, [0.8, 0.8, 0.8]);
sim.update(1.0 / 60.0);
let before = read_channel(&sim, &sim.dye.read, 0).iter().sum::<f32>();
sim.resize(512, 256);
assert_eq!(sim.size(), (512, 256));
let after = read_channel(&sim, &sim.dye.read, 0).iter().sum::<f32>();
assert!(
after > before * 0.5,
"the resize lost the dye ({before} -> {after})"
);
let (sw, sh) = (sim.velocity.width(), sim.velocity.height());
assert!(sw > sh, "sim grid did not follow the canvas ({sw}x{sh})");
sim.update(1.0 / 60.0);
}
#[test]
fn display_options_do_not_touch_the_fields() {
let Some(mut sim) = sim(256, 256, FluidConfig::default()) else {
eprintln!("skipping: no GPU adapter");
return;
};
sim.multiple_splats(6);
for _ in 0..10 {
sim.update(1.0 / 60.0);
}
let before = read_channel(&sim, &sim.velocity.read, 0);
sim.set_config(FluidConfig {
bloom: false,
sunrays: false,
shading: false,
..*sim.config()
});
let after = read_channel(&sim, &sim.velocity.read, 0);
assert_eq!(
before, after,
"a display toggle reallocated the velocity field"
);
sim.set_config(FluidConfig {
sim_resolution: 64,
..*sim.config()
});
assert_eq!(sim.velocity.width().min(sim.velocity.height()), 64);
}
#[test]
fn zero_sweeps_is_refused() {
let Some((device, queue, formats)) = device() else {
eprintln!("skipping: no GPU adapter");
return;
};
let built = FluidSim::with_formats(
device,
queue,
64,
64,
FluidConfig {
pressure_iterations: 0,
..FluidConfig::default()
},
formats,
);
let Err(err) = built else {
panic!("a simulation with no pressure sweeps was accepted");
};
assert!(err.contains("pressure_iterations"), "{err}");
}
#[test]
fn the_top_quality_level_runs_or_degrades() {
let extreme = quality("extreme").expect("a level called extreme");
let Some(mut sim) = sim(3840, 1080, FluidConfig::default().with_quality(extreme)) else {
eprintln!("skipping: no GPU adapter");
return;
};
let max = sim.max_dim;
let ((dw, dh), (sw, sh)) = sim.grid_sizes();
assert!(
dw <= max && dh <= max,
"dye grid {dw}x{dh} over the limit {max}"
);
assert!(
sw <= max && sh <= max,
"sim grid {sw}x{sh} over the limit {max}"
);
eprintln!(
"extreme on 3840x1080: dye {dw}x{dh}, sim {sw}x{sh}, {} MB",
sim.memory_bytes() / (1024 * 1024)
);
sim.multiple_splats(4);
sim.update(1.0 / 60.0);
let rgba = sim.capture_rgba(320, 90);
assert!(
rgba.iter().any(|&b| b > 8),
"the top level rendered nothing"
);
}
#[test]
fn the_dye_can_be_a_material_map() {
use crate::renderer::RenderTarget;
use crate::textures::Texture;
use crate::{
BasicMaterial, Color, HeadlessRenderer, Mesh, Object3D, PerspectiveCamera, PlaneGeometry,
Scene, TextureFormat, Vector3,
};
let Ok(mut hr) = HeadlessRenderer::builder().size(256, 256).build() else {
eprintln!("skipping: no GPU adapter");
return;
};
let (device, queue) = (hr.device().clone(), hr.queue().clone());
let rt = Arc::new(RenderTarget::new(
&device,
256,
256,
wgpu::TextureFormat::Rgba8Unorm,
));
let Ok(mut sim) = FluidSim::new(device, queue, 256, 256, FluidConfig::default()) else {
eprintln!("skipping: no GPU adapter");
return;
};
sim.multiple_splats(14);
for _ in 0..16 {
sim.update(1.0 / 60.0);
}
sim.render_capture(&rt.color_texture);
const RT_ID: u32 = 4242;
hr.renderer().register_render_target(RT_ID, &rt);
let mut material = BasicMaterial::new(Color::WHITE);
material.map = Some(Arc::new(Texture::from_render_target(
RT_ID,
256,
256,
TextureFormat::Rgba8Unorm,
)));
let mut scene = Scene::new();
scene.background = Color::BLACK;
scene.add(Object3D::mesh(Mesh::new(
PlaneGeometry::new(2.0, 2.0),
material.into(),
)));
let mut camera = PerspectiveCamera::new(60.0, 1.0, 0.1, 10.0);
camera.position = Vector3::new(0.0, 0.0, 1.0);
camera.look_at(Vector3::ZERO);
let rgba = hr.render_to_rgba(&mut scene, &camera);
let saturated = rgba
.chunks_exact(4)
.filter(|p| {
let (hi, lo) = (p[0].max(p[1]).max(p[2]), p[0].min(p[1]).min(p[2]));
hi > 40 && hi - lo > 40
})
.count();
assert!(
saturated > 500,
"only {saturated} pixels carry a hue; the dye did not reach the material"
);
}
#[test]
fn the_fluid_can_be_a_pass_in_the_composer() {
use crate::postprocessing::{DrawPass, EffectComposer, RenderPass};
use crate::renderer::{readback, RenderTarget};
let Some(gpu) = crate::gpu::testing::context("fluid as a pass") else {
return;
};
let format = wgpu::TextureFormat::Rgba8Unorm;
let (w, h) = (128u32, 128u32);
let mut sim = FluidSim::new(
gpu.device.clone(),
gpu.queue.clone(),
w,
h,
FluidConfig {
transparent: true,
..FluidConfig::default()
},
)
.expect("fluid");
sim.multiple_splats(10);
for _ in 0..12 {
sim.update(1.0 / 60.0);
}
let mut renderer = crate::Renderer::new(gpu.device.clone(), gpu.queue.clone(), format, w, h);
let mut composer = EffectComposer::new(gpu.device.clone(), gpu.queue.clone(), w, h, format);
composer.add_pass(RenderPass::new());
composer.add_pass(DrawPass::new("fluid", move |ctx| {
sim.update(1.0 / 60.0);
sim.render_into(ctx.target(), true);
}));
let out = RenderTarget::new(&gpu.device, w, h, format);
let mut scene = crate::Scene::new();
scene.background = crate::Color::BLACK;
let mut camera = crate::PerspectiveCamera::new(50.0, 1.0, 0.1, 10.0);
camera.position = crate::Vector3::new(0.0, 0.0, 3.0);
composer.render(&mut renderer, &mut scene, &camera, &out.color_view);
let pixels = readback::texture_bytes(&gpu.device, &gpu.queue, &out.color_texture);
let coloured = pixels
.chunks_exact(4)
.filter(|p| {
let (hi, lo) = (p[0].max(p[1]).max(p[2]), p[0].min(p[1]).min(p[2]));
hi > 40 && hi - lo > 30
})
.count();
assert!(
coloured > 200,
"only {coloured} pixels carry dye; the pass did not reach the final frame"
);
}
#[test]
fn multigrid_beats_sixty_four_times_the_jacobi_sweeps() {
let residual = |solver: PressureSolver, iterations: u32, cycles: u32| -> Option<f32> {
let mut sim = sim(
256,
256,
FluidConfig {
pressure_solver: solver,
pressure_iterations: iterations,
multigrid_cycles: cycles,
gradient_scale: 0.5,
curl: 0.0,
..FluidConfig::default()
},
)?;
sim.splat(0.5, 0.5, 400.0, 0.0, [0.3, 0.3, 0.3]);
let raw = divergence_now(&mut sim);
sim.step(0.0);
Some(divergence_now(&mut sim) / raw)
};
let (Some(j20), Some(j1280), Some(mg1), Some(mg2)) = (
residual(PressureSolver::Jacobi, 20, 1),
residual(PressureSolver::Jacobi, 1280, 1),
residual(PressureSolver::Multigrid, 20, 1),
residual(PressureSolver::Multigrid, 20, 2),
) else {
eprintln!("skipping: no GPU adapter");
return;
};
eprintln!(" jacobi 20 sweeps: {j20:.3}");
eprintln!(" jacobi 1280 sweeps: {j1280:.3}");
eprintln!(" multigrid 1 cycle : {mg1:.3}");
eprintln!(" multigrid 2 cycles: {mg2:.3}");
assert!(
mg1 < j1280,
"one V-cycle left {mg1:.3} against 1280 Jacobi sweeps' {j1280:.3}"
);
assert!(
mg1 < j20 * 0.5,
"one V-cycle left {mg1:.3} against the default's {j20:.3}"
);
assert!(
mg2 < mg1 * 0.6,
"a second cycle took {mg1:.3} only to {mg2:.3}"
);
assert!(mg2 < 0.15, "two cycles still leave {mg2:.3}");
}
#[test]
fn the_multigrid_solver_is_still_a_fluid() {
let Some(mut sim) = sim(
256,
256,
FluidConfig {
pressure_solver: PressureSolver::Multigrid,
bloom: false,
sunrays: false,
shading: false,
..FluidConfig::default()
},
) else {
eprintln!("skipping: no GPU adapter");
return;
};
sim.splat(0.25, 0.25, 0.0, 0.0, [0.6, 0.6, 0.6]);
sim.update(1.0 / 60.0);
let (x, y, v) = brightest(&sim.capture_rgba(256, 256), 256, 256);
assert!(v > 32, "nothing was drawn (brightest {v})");
assert!((x - 0.25).abs() < 0.05, "x {x}");
assert!((y - 0.25).abs() < 0.05, "y {y}");
for i in 0..60 {
let t = i as f32 / 60.0;
sim.splat(t, 1.0 - t, 2500.0, -2500.0, [1.0, 1.0, 1.0]);
sim.update(1.0 / 60.0);
}
for channel in 0..2 {
let field = read_channel(&sim, &sim.velocity.read, channel);
assert!(
field.iter().all(|x| x.is_finite()),
"velocity channel {channel} went non-finite under the multigrid solver"
);
let worst = field.iter().copied().fold(0.0f32, |a, b| a.max(b.abs()));
assert!(worst < 1.0e4, "velocity reached {worst}");
}
}
#[test]
fn a_grid_too_small_to_coarsen_still_solves() {
let Some(mut sim) = sim(
64,
64,
FluidConfig {
pressure_solver: PressureSolver::Multigrid,
sim_resolution: 8,
..FluidConfig::default()
},
) else {
eprintln!("skipping: no GPU adapter");
return;
};
assert!(
sim.mg.len() <= 1,
"an 8-texel grid built {} levels",
sim.mg.len()
);
sim.multiple_splats(4);
sim.update(1.0 / 60.0);
let field = read_channel(&sim, &sim.velocity.read, 0);
assert!(field.iter().all(|x| x.is_finite()));
}
#[test]
fn maccormack_advection_diffuses_less() {
let run = |advection: Advection| -> Option<(f32, f32)> {
let mut sim = sim(
256,
256,
FluidConfig {
advection,
dye_resolution: 256,
splat_radius: 0.02,
density_dissipation: 0.0,
velocity_dissipation: 0.0,
curl: 0.0,
..FluidConfig::default()
},
)?;
sim.splat(0.25, 0.5, 0.0, 0.0, [1.0, 1.0, 1.0]);
sim.set_uniform_velocity(30.0, 0.0);
for _ in 0..100 {
sim.step(1.0 / 60.0);
}
let dye = read_channel(&sim, &sim.dye.read, 0);
let peak = dye.iter().copied().fold(0.0f32, f32::max);
let mass = dye.iter().sum::<f32>();
Some((peak, mass))
};
let (Some((sl_peak, sl_mass)), Some((mc_peak, mc_mass))) =
(run(Advection::SemiLagrangian), run(Advection::MacCormack))
else {
eprintln!("skipping: no GPU adapter");
return;
};
eprintln!(" semi-Lagrangian: peak {sl_peak:.4}, mass {sl_mass:.1}");
eprintln!(" MacCormack: peak {mc_peak:.4}, mass {mc_mass:.1}");
assert!(sl_peak > 0.0, "the dye vanished");
assert!(
mc_peak > sl_peak * 1.3,
"MacCormack held {mc_peak:.4} against semi-Lagrangian's {sl_peak:.4} \
— not the sharper blob it is for"
);
assert!(
mc_mass < sl_mass * 1.1,
"MacCormack carries {mc_mass:.1} against {sl_mass:.1} — the limiter \
is not holding"
);
}
#[test]
fn the_plane_draws_its_read_out_too() {
let (w, h) = (128u32, 128u32);
let render = |show: bool| -> Option<Vec<u8>> {
let mut sim = sim(
w,
h,
FluidConfig {
show_fps: show,
bloom: false,
sunrays: false,
..FluidConfig::default()
},
)?;
sim.multiple_splats(4);
for _ in 0..4 {
sim.update(1.0 / 60.0);
sim.capture_rgba(w, h);
}
Some(sim.capture_rgba(w, h))
};
let Some(plain) = render(false) else {
eprintln!("skipping: no GPU adapter");
return;
};
let with = render(true).expect("a second simulation");
let in_read_out = |x: u32, y: u32| {
let digits = x < 10 + 12 * 3 && y < 10 + 5 * 3;
let chart = (10..10 + 64 * 2).contains(&x) && (29..29 + 18).contains(&y);
digits || chart
};
let (mut inside, mut outside) = (0usize, 0usize);
for y in 0..h {
for x in 0..w {
let i = ((y * w + x) * 4) as usize;
if plain[i..i + 4] == with[i..i + 4] {
continue;
}
if in_read_out(x, y) {
inside += 1;
} else {
outside += 1;
}
}
}
eprintln!(" the plane's read-out changed {inside} pixels inside its box, {outside} outside");
assert!(inside > 20, "the read-out drew {inside} pixels");
assert_eq!(outside, 0, "it changed {outside} pixels outside its box");
}
#[test]
fn the_read_out_shows_the_number_it_was_given() {
let (w, h) = (96u32, 48u32);
let Some(mut sim) = sim(
w,
h,
FluidConfig {
show_fps: true,
bloom: false,
sunrays: false,
transparent: false,
back_color: [0.0; 3],
..FluidConfig::default()
},
) else {
eprintln!("skipping: no GPU adapter");
return;
};
let read = |px: &[u8]| -> String {
let lit = |cx: usize, cy: usize| -> bool {
let (x, y) = (10 + cx * 3 + 1, 10 + cy * 3 + 1);
px[(y * w as usize + x) * 4] > 120
};
let shapes: [(&str, [[bool; 3]; 5]); 11] = [
(" ", [[false; 3]; 5]),
(
"0",
[
[true, true, true],
[true, false, true],
[true, false, true],
[true, false, true],
[true, true, true],
],
),
(
"1",
[
[false, true, false],
[true, true, false],
[false, true, false],
[false, true, false],
[true, true, true],
],
),
(
"2",
[
[true, true, true],
[false, false, true],
[true, true, true],
[true, false, false],
[true, true, true],
],
),
(
"3",
[
[true, true, true],
[false, false, true],
[true, true, true],
[false, false, true],
[true, true, true],
],
),
(
"4",
[
[true, false, true],
[true, false, true],
[true, true, true],
[false, false, true],
[false, false, true],
],
),
(
"5",
[
[true, true, true],
[true, false, false],
[true, true, true],
[false, false, true],
[true, true, true],
],
),
(
"6",
[
[true, true, true],
[true, false, false],
[true, true, true],
[true, false, true],
[true, true, true],
],
),
(
"7",
[
[true, true, true],
[false, false, true],
[false, false, true],
[false, false, true],
[false, false, true],
],
),
(
"8",
[
[true, true, true],
[true, false, true],
[true, true, true],
[true, false, true],
[true, true, true],
],
),
(
"9",
[
[true, true, true],
[true, false, true],
[true, true, true],
[false, false, true],
[true, true, true],
],
),
];
(0..3)
.map(|col| {
let seen: [[bool; 3]; 5] =
std::array::from_fn(|y| std::array::from_fn(|x| lit(col * 4 + x, y)));
shapes
.iter()
.find(|(_, want)| *want == seen)
.map(|(name, _)| *name)
.unwrap_or("?")
})
.collect()
};
for (value, want) in [
(7.0f32, " 7"),
(42.0, " 42"),
(99.0, " 99"),
(100.0, "100"),
(999.0, "999"),
] {
sim.set_fps_for_test(value);
let px = sim.capture_rgba(w, h);
let got = read(&px);
eprintln!(" {value:>5} shows {got:?}");
assert_eq!(got, want, "the read-out showed {got:?} for {value}");
}
}
#[test]
fn the_chart_shows_the_frame_times_it_was_given() {
let (w, h) = (160u32, 64u32);
let Some(mut sim) = sim(
w,
h,
FluidConfig {
show_fps: true,
bloom: false,
sunrays: false,
transparent: false,
back_color: [0.0; 3],
..FluidConfig::default()
},
) else {
eprintln!("skipping: no GPU adapter");
return;
};
let bar = |px: &[u8], column: usize| -> usize {
let x = 10 + column * 2;
(0..18)
.filter(|row| {
let y = 29 + row;
let i = (y * w as usize + x) * 4;
px[i] > 60 || px[i + 2] > 60
})
.count()
};
sim.set_frame_times_for_test(&[1000.0 / 60.0; 64]);
let flat = sim.capture_rgba(w, h);
let mut spiky = [1000.0f32 / 60.0; 64];
spiky[40] = 1000.0 / 10.0; sim.set_frame_times_for_test(&spiky);
let hitched = sim.capture_rgba(w, h);
let steady: Vec<usize> = (0..64).map(|c| bar(&flat, c)).collect();
let spiked: Vec<usize> = (0..64).map(|c| bar(&hitched, c)).collect();
eprintln!(
" flat: bars {}..{} tall; with a hitch at 40: column 40 is {} and its neighbour {}",
steady.iter().min().unwrap(),
steady.iter().max().unwrap(),
spiked[40],
spiked[39]
);
assert!(
steady.iter().all(|t| (7..=10).contains(t)),
"a steady {:.1} ms should sit at half of eighteen: {steady:?}",
1000.0 / 60.0
);
assert!(
spiked[40] > spiked[39] + 4,
"the hitch did not show: {} against {}",
spiked[40],
spiked[39]
);
assert_eq!(
spiked[39], steady[39],
"a hitch in one frame changed another column"
);
}