use std::mem::size_of;
use super::device::{MetalDevice, MetalError};
use super::enums::*;
use super::objc::{msg0, msg1, msg2, msg3, sel, AutoreleasePool, Id, Owned};
use super::postfx::{encode_fullscreen, fullscreen_pipeline_blend, fullscreen_pipeline_with};
use super::resources::{new_texture_2d, upload_texture_2d};
use super::target::{blit_texture_to_buffer_on_cmd, finish_texture_readback_into};
use crate::fluid::passes::{Params, FLAG_ENCODE, FLAG_SHADING};
use crate::fluid::read_out::{Frames, Rate};
use crate::fluid::FluidConfig;
const FORMAT: NSUInteger = pixel_format::RGBA16_FLOAT;
struct Pair {
read: Owned,
write: Owned,
}
impl Pair {
fn new(device: &MetalDevice, w: u32, h: u32) -> Result<Self, MetalError> {
Ok(Self {
read: field(device, w, h)?,
write: field(device, w, h)?,
})
}
fn swap(&mut self) {
std::mem::swap(&mut self.read, &mut self.write);
}
}
fn field(device: &MetalDevice, w: u32, h: u32) -> Result<Owned, MetalError> {
new_texture_2d(
device,
w,
h,
FORMAT,
texture_usage::SHADER_READ | texture_usage::RENDER_TARGET,
storage_mode::PRIVATE,
1,
1,
)
}
struct Pipelines {
clear: Owned,
splat: Owned,
advection: Owned,
divergence: Owned,
curl: Owned,
vorticity: Owned,
pressure: Owned,
gradient: Owned,
display: Vec<(NSUInteger, Owned)>,
display_over: Vec<(NSUInteger, Owned)>,
color: Vec<(NSUInteger, Owned)>,
overlay: Vec<(NSUInteger, Owned)>,
}
pub struct MetalFluid {
config: FluidConfig,
width: u32,
height: u32,
sim: (u32, u32),
dye_size: (u32, u32),
velocity: Pair,
dye: Pair,
pressure: Pair,
divergence: Owned,
curl: Owned,
pipes: Pipelines,
params: Vec<Owned>,
next_param: usize,
rng: u64,
colour_timer: f32,
paused: bool,
rate: Rate,
history: Owned,
}
impl MetalFluid {
pub fn new(
device: &MetalDevice,
width: u32,
height: u32,
config: FluidConfig,
) -> Result<Self, MetalError> {
if config.pressure_iterations == 0 {
return Err(MetalError::Unsupported(
"fluid: pressure_iterations must be at least 1".into(),
));
}
let (width, height) = (width.max(1), height.max(1));
let sim = grid(config.sim_resolution, width, height);
let dye_size = grid(config.dye_resolution, width, height);
let p = |name: &str| fullscreen_pipeline_with(device, "vs_fluid", name, FORMAT);
let pipes = Pipelines {
clear: p("fs_fluid_clear")?,
splat: p("fs_fluid_splat")?,
advection: p("fs_fluid_advection")?,
divergence: p("fs_fluid_divergence")?,
curl: p("fs_fluid_curl")?,
vorticity: p("fs_fluid_vorticity")?,
pressure: p("fs_fluid_pressure")?,
gradient: p("fs_fluid_gradient")?,
display: Vec::new(),
display_over: Vec::new(),
color: Vec::new(),
overlay: Vec::new(),
};
let params = (0..16)
.map(|_| device.new_buffer(&[0u8; size_of::<Params>()]))
.collect::<Result<Vec<_>, _>>()?;
let fluid = Self {
velocity: Pair::new(device, sim.0, sim.1)?,
dye: Pair::new(device, dye_size.0, dye_size.1)?,
pressure: Pair::new(device, sim.0, sim.1)?,
divergence: field(device, sim.0, sim.1)?,
curl: field(device, sim.0, sim.1)?,
config,
width,
height,
sim,
dye_size,
pipes,
params,
next_param: 0,
rng: config.seed | 1,
colour_timer: 0.0,
paused: false,
rate: Rate::default(),
history: new_texture_2d(
device,
Frames::LEN as u32,
1,
pixel_format::RGBA8_UNORM,
texture_usage::SHADER_READ,
storage_mode::SHARED,
1,
1,
)?,
};
fluid.zero_fields(device)?;
Ok(fluid)
}
fn zero_fields(&self, device: &MetalDevice) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
let cmd = self.command_buffer(device);
for t in [
self.velocity.read.id(),
self.velocity.write.id(),
self.dye.read.id(),
self.dye.write.id(),
self.pressure.read.id(),
self.pressure.write.id(),
self.divergence.id(),
self.curl.id(),
] {
clear_to_zero(cmd, t)?;
}
commit(cmd);
Ok(())
}
pub fn unsupported(config: &FluidConfig) -> Vec<&'static str> {
let mut out = Vec::new();
if !matches!(config.pressure_solver, crate::fluid::PressureSolver::Jacobi) {
out.push("pressure_solver: only Jacobi is implemented here");
}
if !matches!(config.advection, crate::fluid::Advection::SemiLagrangian) {
out.push("advection: only semi-Lagrangian is implemented here");
}
if config.bloom {
out.push("bloom");
}
if config.sunrays {
out.push("sunrays");
}
if config.colorful {
out.push("colorful: splat hues do not advance on their own here");
}
out
}
pub fn config(&self) -> &FluidConfig {
&self.config
}
pub fn size(&self) -> (u32, u32) {
(self.width, self.height)
}
pub fn grid_sizes(&self) -> ((u32, u32), (u32, u32)) {
(self.dye_size, self.sim)
}
pub fn set_paused(&mut self, paused: bool) {
self.paused = paused;
}
pub fn paused(&self) -> bool {
self.paused
}
fn next_f32(&mut self) -> f32 {
let mut x = self.rng;
x ^= x >> 12;
x ^= x << 25;
x ^= x >> 27;
self.rng = x;
((x.wrapping_mul(0x2545_F491_4F6C_DD1D) >> 40) as f32) / 16_777_216.0
}
pub fn multiple_splats(&mut self, device: &MetalDevice, count: u32) {
for _ in 0..count {
let hue = self.next_f32();
let c = crate::fluid::hsv_to_rgb_for_backends(hue, 1.0, 1.0);
let colour = [c[0] * 1.5, c[1] * 1.5, c[2] * 1.5];
let x = self.next_f32();
let y = self.next_f32();
let dx = 1000.0 * (self.next_f32() - 0.5);
let dy = 1000.0 * (self.next_f32() - 0.5);
let _ = self.splat(device, x, y, dx, dy, colour);
}
}
pub fn splat(
&mut self,
device: &MetalDevice,
x: f32,
y: f32,
dx: f32,
dy: f32,
color: [f32; 3],
) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
let aspect = self.width as f32 / self.height as f32;
let mut radius = self.config.splat_radius / 100.0;
if aspect > 1.0 {
radius *= aspect;
}
let base = Params {
point: [x, y],
aspect_ratio: aspect,
radius,
..Default::default()
};
let cmd = self.command_buffer(device);
self.next_param = 0;
let u = self.write_params(Params {
color: [dx, dy, 0.0, 1.0],
..base
});
encode(cmd, &self.pipes.splat, self.velocity.write.id(), |enc| {
bind(enc, u, &[self.velocity.read.id()]);
})?;
let u = self.write_params(Params {
color: [color[0], color[1], color[2], 1.0],
..base
});
encode(cmd, &self.pipes.splat, self.dye.write.id(), |enc| {
bind(enc, u, &[self.dye.read.id()]);
})?;
commit(cmd);
self.velocity.swap();
self.dye.swap();
Ok(())
}
pub fn update(&mut self, device: &MetalDevice, dt: f32) {
let dt = dt * self.config.time_scale.max(0.0);
if !self.paused && dt > 0.0 {
let _ = self.step(device, dt);
}
let _ = self.colour_timer;
}
pub fn set_time_scale(&mut self, scale: f32) {
self.config.time_scale = scale.max(0.0);
}
pub fn step(&mut self, device: &MetalDevice, dt: f32) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
let c = self.config;
let texel = [1.0 / self.sim.0 as f32, 1.0 / self.sim.1 as f32];
let cmd = self.command_buffer(device);
self.next_param = 0;
let plain = Params {
texel_size: texel,
..Default::default()
};
let u = self.write_params(plain);
encode(cmd, &self.pipes.curl, self.curl.id(), |enc| {
bind(enc, u, &[self.velocity.read.id()]);
})?;
let u = self.write_params(Params {
texel_size: texel,
dt,
curl: c.curl,
..Default::default()
});
encode(
cmd,
&self.pipes.vorticity,
self.velocity.write.id(),
|enc| {
bind(enc, u, &[self.velocity.read.id(), self.curl.id()]);
},
)?;
self.velocity.swap();
let u = self.write_params(plain);
encode(cmd, &self.pipes.divergence, self.divergence.id(), |enc| {
bind(enc, u, &[self.velocity.read.id()]);
})?;
let u = self.write_params(Params {
value: c.pressure,
..Default::default()
});
encode(cmd, &self.pipes.clear, self.pressure.write.id(), |enc| {
bind(enc, u, &[self.pressure.read.id()]);
})?;
self.pressure.swap();
let u = self.write_params(Params {
texel_size: texel,
value: 1.0,
..Default::default()
});
for i in 0..c.pressure_iterations {
let (src, dst) = if i % 2 == 0 {
(self.pressure.read.id(), self.pressure.write.id())
} else {
(self.pressure.write.id(), self.pressure.read.id())
};
encode(cmd, &self.pipes.pressure, dst, |enc| {
bind(enc, u, &[src, self.divergence.id()]);
})?;
}
if c.pressure_iterations % 2 == 1 {
self.pressure.swap();
}
let u = self.write_params(Params {
texel_size: texel,
value: c.gradient_scale,
..Default::default()
});
encode(cmd, &self.pipes.gradient, self.velocity.write.id(), |enc| {
bind(enc, u, &[self.pressure.read.id(), self.velocity.read.id()]);
})?;
self.velocity.swap();
let u = self.write_params(Params {
texel_size: texel,
dt,
dissipation: c.velocity_dissipation,
..Default::default()
});
encode(
cmd,
&self.pipes.advection,
self.velocity.write.id(),
|enc| {
bind(enc, u, &[self.velocity.read.id(), self.velocity.read.id()]);
},
)?;
self.velocity.swap();
let u = self.write_params(Params {
texel_size: texel,
dt,
dissipation: c.density_dissipation,
..Default::default()
});
encode(cmd, &self.pipes.advection, self.dye.write.id(), |enc| {
bind(enc, u, &[self.velocity.read.id(), self.dye.read.id()]);
})?;
self.dye.swap();
commit(cmd);
Ok(())
}
pub fn render(
&mut self,
device: &MetalDevice,
target: Id,
format: NSUInteger,
size: (u32, u32),
) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
self.ensure_output_pipelines(device, format)?;
let cmd = self.command_buffer(device);
self.next_param = 0;
let c = self.config;
let encode_srgb = if format == pixel_format::RGBA8_UNORM_SRGB {
FLAG_ENCODE
} else {
0
};
let (w, h) = (size.0.max(1), size.1.max(1));
if !c.transparent {
let u = self.write_params(Params {
color: [c.back_color[0], c.back_color[1], c.back_color[2], 1.0],
flags: encode_srgb,
..Default::default()
});
let pipeline = self.output(&self.pipes.color, format);
encode(cmd, pipeline, target, |enc| {
bind(enc, u, &[self.dye.read.id()]);
})?;
}
let mut flags = encode_srgb;
if c.shading {
flags |= FLAG_SHADING;
}
let u = self.write_params(Params {
texel_size: [1.0 / w as f32, 1.0 / h as f32],
flags,
..Default::default()
});
let over = !c.transparent;
let pipeline = if over {
self.output(&self.pipes.display_over, format)
} else {
self.output(&self.pipes.display, format)
};
encode_over(cmd, pipeline, target, over, |enc| {
bind(enc, u, &[self.dye.read.id()]);
})?;
if c.show_fps {
upload_texture_2d(
&self.history,
Frames::LEN as u32,
1,
4,
&self.rate.frames().row(),
)?;
let u = self.write_params(Params {
value: self.rate.fps(),
radius: self.rate.scale_ms(),
curl: self.rate.target_ms(),
..Default::default()
});
let pipeline = self.output(&self.pipes.overlay, format);
encode_over(cmd, pipeline, target, true, |enc| {
bind(enc, u, &[self.history.id()]);
})?;
}
commit(cmd);
self.rate.tick();
Ok(())
}
pub fn fps(&self) -> f32 {
self.rate.fps()
}
pub fn capture_rgba(&mut self, device: &MetalDevice) -> Result<Vec<u8>, MetalError> {
let (w, h) = (self.width, self.height);
let target = new_texture_2d(
device,
w,
h,
pixel_format::RGBA8_UNORM,
texture_usage::SHADER_READ | texture_usage::RENDER_TARGET,
storage_mode::PRIVATE,
1,
1,
)?;
self.render(device, target.id(), pixel_format::RGBA8_UNORM, (w, h))?;
let padded = (w as usize * 4).div_ceil(256) * 256;
let staging = device.new_buffer(&vec![0u8; padded * h as usize])?;
let cmd = self.command_buffer(device);
blit_texture_to_buffer_on_cmd(cmd, target.id(), w, h, &staging, padded)?;
unsafe {
let _: () = msg0(cmd, sel!("commit"));
}
let mut out = Vec::new();
finish_texture_readback_into(cmd, &staging, w, h, pixel_format::RGBA8_UNORM, &mut out)?;
Ok(out)
}
fn command_buffer(&self, device: &MetalDevice) -> Id {
unsafe { msg0(device.queue_id(), sel!("commandBuffer")) }
}
fn write_params(&mut self, params: Params) -> Id {
let i = self.next_param.min(self.params.len() - 1);
self.next_param = i + 1;
let buffer = self.params[i].id();
unsafe {
let contents: *mut u8 = msg0(buffer, sel!("contents"));
std::ptr::copy_nonoverlapping(
bytemuck::bytes_of(¶ms).as_ptr(),
contents,
size_of::<Params>(),
);
}
buffer
}
fn ensure_output_pipelines(
&mut self,
device: &MetalDevice,
format: NSUInteger,
) -> Result<(), MetalError> {
if !self.pipes.display.iter().any(|(f, _)| *f == format) {
let p = fullscreen_pipeline_with(device, "vs_fluid", "fs_fluid_display", format)?;
self.pipes.display.push((format, p));
}
if !self.pipes.display_over.iter().any(|(f, _)| *f == format) {
let p =
fullscreen_pipeline_blend(device, "vs_fluid", "fs_fluid_display", format, true)?;
self.pipes.display_over.push((format, p));
}
if !self.pipes.color.iter().any(|(f, _)| *f == format) {
let p = fullscreen_pipeline_with(device, "vs_fluid", "fs_fluid_color", format)?;
self.pipes.color.push((format, p));
}
if self.config.show_fps && !self.pipes.overlay.iter().any(|(f, _)| *f == format) {
let p =
fullscreen_pipeline_blend(device, "vs_fluid", "fs_fluid_overlay", format, true)?;
self.pipes.overlay.push((format, p));
}
Ok(())
}
fn output<'a>(&'a self, list: &'a [(NSUInteger, Owned)], format: NSUInteger) -> &'a Owned {
list.iter()
.find(|(f, _)| *f == format)
.map(|(_, p)| p)
.expect("ensure_output_pipelines ran first")
}
}
fn grid(resolution: u32, width: u32, height: u32) -> (u32, u32) {
let aspect = width.max(1) as f32 / height.max(1) as f32;
let aspect = if aspect < 1.0 { 1.0 / aspect } else { aspect };
let min = resolution.max(1);
let max = ((resolution as f32 * aspect).round() as u32).max(1);
if width > height {
(max, min)
} else {
(min, max)
}
}
fn bind(enc: Id, params: Id, textures: &[Id]) {
unsafe {
let _: () = msg3(
enc,
sel!("setFragmentBuffer:offset:atIndex:"),
params,
0usize,
0usize,
);
let _: () = msg3(
enc,
sel!("setVertexBuffer:offset:atIndex:"),
params,
0usize,
0usize,
);
for (i, t) in textures.iter().enumerate() {
let _: () = msg2(enc, sel!("setFragmentTexture:atIndex:"), *t, i);
}
}
}
fn encode(cmd: Id, pipeline: &Owned, dst: Id, bind: impl FnOnce(Id)) -> Result<(), MetalError> {
encode_fullscreen(cmd, pipeline.id(), dst, 0, bind)
}
fn encode_over(
cmd: Id,
pipeline: &Owned,
dst: Id,
load: bool,
binder: impl FnOnce(Id),
) -> Result<(), MetalError> {
if !load {
return encode(cmd, pipeline, dst, binder);
}
let _pool = AutoreleasePool::new();
unsafe {
let desc = super::postfx::render_pass_descriptor(dst);
let attachments: Id = msg0(desc, sel!("colorAttachments"));
let color: Id = msg1(attachments, sel!("objectAtIndexedSubscript:"), 0usize);
let _: () = msg1(color, sel!("setLoadAction:"), load_action::LOAD);
let enc: Id = msg1(cmd, sel!("renderCommandEncoderWithDescriptor:"), desc);
if enc.is_null() {
return Err(MetalError::Unsupported(
"fluid render encoder failed".into(),
));
}
let _: () = msg1(enc, sel!("setRenderPipelineState:"), pipeline.id());
binder(enc);
let _: () = msg3(
enc,
sel!("drawPrimitives:vertexStart:vertexCount:"),
primitive::TRIANGLE,
0usize,
3usize,
);
let _: () = msg0(enc, sel!("endEncoding"));
}
Ok(())
}
fn clear_to_zero(cmd: Id, dst: Id) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
unsafe {
let desc = super::postfx::render_pass_descriptor(dst);
let attachments: Id = msg0(desc, sel!("colorAttachments"));
let color: Id = msg1(attachments, sel!("objectAtIndexedSubscript:"), 0usize);
let _: () = msg1(
color,
sel!("setClearColor:"),
MTLClearColor {
red: 0.0,
green: 0.0,
blue: 0.0,
alpha: 0.0,
},
);
let enc: Id = msg1(cmd, sel!("renderCommandEncoderWithDescriptor:"), desc);
if enc.is_null() {
return Err(MetalError::Unsupported("fluid clear encoder failed".into()));
}
let _: () = msg0(enc, sel!("endEncoding"));
}
Ok(())
}
fn commit(cmd: Id) {
unsafe {
let _: () = msg0(cmd, sel!("commit"));
let _: () = msg0(cmd, sel!("waitUntilCompleted"));
}
}
#[cfg(all(
test,
feature = "metal",
feature = "fluid",
any(target_os = "macos", target_os = "ios")
))]
mod gpu_tests {
use super::*;
use crate::metal::fluid_shader_source;
fn device() -> Option<MetalDevice> {
match MetalDevice::with_shader_source(&fluid_shader_source()) {
Ok(d) => Some(d),
Err(e) => {
eprintln!("skipping: {e}");
None
}
}
}
fn dump(fluid: &mut MetalFluid, device: &MetalDevice, src: Id) -> Vec<u8> {
let (w, h) = (128, 128);
let target = new_texture_2d(
device,
w,
h,
pixel_format::RGBA8_UNORM,
texture_usage::SHADER_READ | texture_usage::RENDER_TARGET,
storage_mode::PRIVATE,
1,
1,
)
.unwrap();
let pipeline = fullscreen_pipeline_with(
device,
"vs_fluid",
"fs_fluid_clear",
pixel_format::RGBA8_UNORM,
)
.unwrap();
let cmd = fluid.command_buffer(device);
fluid.next_param = 0;
let u = fluid.write_params(Params {
value: 1.0,
..Default::default()
});
encode(cmd, &pipeline, target.id(), |enc| bind(enc, u, &[src])).unwrap();
commit(cmd);
let padded = (w as usize * 4).div_ceil(256) * 256;
let staging = device.new_buffer(&vec![0u8; padded * h as usize]).unwrap();
let cmd = fluid.command_buffer(device);
blit_texture_to_buffer_on_cmd(cmd, target.id(), w, h, &staging, padded).unwrap();
unsafe {
let _: () = msg0(cmd, sel!("commit"));
}
let mut out = Vec::new();
finish_texture_readback_into(cmd, &staging, w, h, pixel_format::RGBA8_UNORM, &mut out)
.unwrap();
out
}
fn brightest(rgba: &[u8]) -> u8 {
rgba.chunks_exact(4)
.map(|p| p[0].max(p[1]).max(p[2]))
.max()
.unwrap_or(0)
}
#[test]
fn the_msl_read_out_agrees_about_the_row() {
let find = |name: &str| -> String {
let at = super::super::FLUID_SHADER_SOURCE
.find(name)
.unwrap_or_else(|| panic!("`{name}` is not declared in fluid.metal"));
let rest = &super::super::FLUID_SHADER_SOURCE[at + name.len()..];
let eq = rest.find('=').expect("a constant is assigned");
rest[eq + 1..]
.split(';')
.next()
.expect("terminated")
.trim()
.to_string()
};
assert_eq!(
find("FLUID_HISTORY_COLUMNS"),
Frames::LEN.to_string(),
"the MSL chart reads a different number of columns than Rust uploads"
);
assert_eq!(
find("FLUID_HISTORY_SCALE_MS").parse::<f32>().unwrap(),
Frames::SCALE_MS,
"the MSL chart decodes a byte as a different number of milliseconds \
than Rust encodes it as"
);
}
#[test]
fn the_metal_read_out_draws_only_where_it_says() {
let Some(device) = device() else { return };
let (w, h) = (160u32, 64u32);
let render = |show: bool| -> Vec<u8> {
let mut fluid = MetalFluid::new(
&device,
w,
h,
FluidConfig {
show_fps: show,
..FluidConfig::default()
},
)
.unwrap();
fluid.multiple_splats(&device, 4);
for _ in 0..4 {
fluid.update(&device, 1.0 / 60.0);
fluid.capture_rgba(&device).unwrap();
}
fluid.capture_rgba(&device).unwrap()
};
let plain = render(false);
let with = render(true);
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 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_two_read_outs_agree() {
use crate::gpu::GpuContext;
let Some(device) = device() else { return };
let Ok(gpu) = GpuContext::headless_blocking() else {
eprintln!("skipping: no wgpu adapter");
return;
};
let (w, h) = (160u32, 64u32);
let config = FluidConfig {
show_fps: true,
bloom: false,
sunrays: false,
colorful: false,
transparent: false,
back_color: [0.0; 3],
..FluidConfig::default()
};
assert!(
MetalFluid::unsupported(&config).is_empty(),
"this backend does not implement {:?}",
MetalFluid::unsupported(&config)
);
let mut times = [1000.0f32 / 60.0; 64];
times[40] = 1000.0 / 10.0;
times[41] = 1000.0 / 240.0;
let mut metal = MetalFluid::new(&device, w, h, config).unwrap();
metal.rate.pin_frame_times(×);
let from_metal = metal.capture_rgba(&device).unwrap();
let mut sim =
crate::fluid::FluidSim::new(gpu.device.clone(), gpu.queue.clone(), w, h, config)
.unwrap();
sim.set_frame_times_for_test(×);
let from_wgpu = sim.capture_rgba(w, h);
let mut worst = 0i32;
let mut differing = 0usize;
for y in 0..h as usize {
for x in 0..w as usize {
let i = (y * w as usize + x) * 4;
for ch in 0..3 {
let d = from_metal[i + ch] as i32 - from_wgpu[i + ch] as i32;
worst = worst.max(d.abs());
if d != 0 {
differing += 1;
}
}
}
}
let lit = from_wgpu
.chunks_exact(4)
.filter(|p| p[0] > 10 || p[1] > 10 || p[2] > 10)
.count();
eprintln!(
" the wgpu read-out lit {lit} pixels; {differing} channels differ, worst {worst}/255"
);
assert!(lit > 400, "the reference drew only {lit} pixels");
assert!(
worst <= 1,
"the two read-outs differ by {worst}/255 over {differing} channels"
);
}
#[test]
fn a_splat_lands_in_the_dye() {
let Some(device) = device() else { return };
let mut fluid = MetalFluid::new(&device, 256, 256, FluidConfig::default()).unwrap();
fluid
.splat(&device, 0.5, 0.5, 0.0, 0.0, [1.0, 0.5, 0.25])
.unwrap();
let src = fluid.dye.read.id();
let dye = dump(&mut fluid, &device, src);
assert!(
brightest(&dye) > 200,
"a splat at the centre left nothing in the dye (brightest {})",
brightest(&dye)
);
}
#[test]
fn the_solver_keeps_the_dye() {
let Some(device) = device() else { return };
let mut fluid = MetalFluid::new(&device, 256, 256, FluidConfig::default()).unwrap();
fluid
.splat(&device, 0.5, 0.5, 0.0, 0.0, [1.0, 0.5, 0.25])
.unwrap();
for _ in 0..10 {
fluid.update(&device, 1.0 / 60.0);
}
let src = fluid.dye.read.id();
let dye = dump(&mut fluid, &device, src);
assert!(
brightest(&dye) > 100,
"ten steps erased the dye (brightest {})",
brightest(&dye)
);
}
#[test]
#[cfg_attr(not(feature = "fluid"), ignore)]
fn metal_fluid_matches_wgpu() {
use crate::gpu::GpuContext;
let Some(device) = device() else { return };
let Ok(gpu) = GpuContext::headless_blocking() else {
eprintln!("skipping: no wgpu adapter");
return;
};
let (w, h) = (320, 192);
let config = FluidConfig {
bloom: false,
sunrays: false,
colorful: false,
..FluidConfig::default()
};
let mut metal = MetalFluid::new(&device, w, h, config).unwrap();
let mut wgpu_sim =
crate::fluid::FluidSim::new(gpu.device.clone(), gpu.queue.clone(), w, h, config)
.unwrap();
assert_eq!(
metal.grid_sizes(),
wgpu_sim.grid_sizes(),
"the two backends sized their grids differently"
);
assert!(
MetalFluid::unsupported(&config).is_empty(),
"the configuration under comparison uses {:?}, which this backend \
does not implement — so this would be measuring the distance \
between two different algorithms",
MetalFluid::unsupported(&config)
);
metal.multiple_splats(&device, 8);
wgpu_sim.multiple_splats(8);
for _ in 0..5 {
metal.update(&device, 1.0 / 60.0);
wgpu_sim.update(1.0 / 60.0);
}
let a = metal.capture_rgba(&device).unwrap();
let b = wgpu_sim.capture_rgba(w, h);
assert_eq!(a.len(), b.len());
let mean = a
.iter()
.zip(&b)
.map(|(x, y)| x.abs_diff(*y) as f64)
.sum::<f64>()
/ a.len() as f64;
assert!(
mean < 2.0,
"the two backends drew different fluids (mean |diff| {mean:.2}/255)"
);
}
#[test]
fn the_background_survives_the_display_pass() {
let Some(device) = device() else { return };
let config = FluidConfig {
back_color: [0.1, 0.2, 0.3],
transparent: false,
..FluidConfig::default()
};
let mut fluid = MetalFluid::new(&device, 64, 64, config).unwrap();
let rgba = fluid.capture_rgba(&device).unwrap();
assert!(
rgba.chunks_exact(4).all(|p| p[3] == 255),
"the picture is not opaque"
);
assert!(
rgba.chunks_exact(4).all(|p| p[0] > 0 && p[2] > p[0]),
"the background colour is not in the picture"
);
}
}