use super::device::{MetalDevice, MetalError};
use super::enums::*;
use super::objc::{msg0, msg1, msg2, msg3, sel, AutoreleasePool, Id, Owned};
use super::pass::{
encode_fullscreen, fullscreen_pipeline_blend, fullscreen_pipeline_with, new_texture_2d, render_pass_descriptor,
};
#[cfg(metal_backend)]
use super::target::{blit_texture_to_buffer_on_cmd, finish_texture_readback_into};
use crate::fluid::passes::{Params, FLAG_BLOOM, FLAG_ENCODE, FLAG_SHADING, FLAG_SUNRAYS};
use crate::fluid::read_out::{Frames, Rate};
use crate::fluid::{Advection, FluidConfig, PressureSolver};
const FORMAT: NSUInteger = pixel_format::RGBA16_FLOAT;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum MetalFieldFormats {
#[default]
Uniform,
Narrow,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct Formats {
dye: NSUInteger,
velocity: NSUInteger,
scalar: NSUInteger,
}
impl From<MetalFieldFormats> for Formats {
fn from(f: MetalFieldFormats) -> Self {
match f {
MetalFieldFormats::Uniform => Self { dye: FORMAT, velocity: FORMAT, scalar: FORMAT },
MetalFieldFormats::Narrow => Self {
dye: FORMAT,
velocity: pixel_format::RG16_FLOAT,
scalar: pixel_format::R16_FLOAT,
},
}
}
}
struct Pair {
read: Owned,
write: Owned,
}
impl Pair {
fn new(device: &MetalDevice, w: u32, h: u32, format: NSUInteger) -> Result<Self, MetalError> {
Ok(Self {
read: field(device, w, h, format)?,
write: field(device, w, h, format)?,
})
}
fn swap(&mut self) {
std::mem::swap(&mut self.read, &mut self.write);
}
}
struct Level {
pressure: Pair,
rhs: Owned,
residual: Owned,
size: (u32, u32),
}
struct Grids {
sim: (u32, u32),
dye_size: (u32, u32),
velocity: Pair,
dye: Pair,
pressure: Pair,
divergence: Owned,
curl: Owned,
scratch_velocity: Owned,
scratch_dye: Owned,
residual: Owned,
mg: Vec<Level>,
bloom: (Owned, (u32, u32)),
bloom_chain: Vec<(Owned, (u32, u32))>,
sunrays: (Owned, (u32, u32)),
sunrays_temp: Owned,
}
impl Grids {
fn new(device: &MetalDevice, c: &FluidConfig, f: Formats, width: u32, height: u32) -> Result<Self, MetalError> {
let sim = grid(c.sim_resolution, width, height);
let dye_size = grid(c.dye_resolution, width, height);
let bloom = grid(c.bloom_resolution, width, height);
let rays = grid(c.sunrays_resolution, width, height);
let mut mg = Vec::new();
let (mut w, mut h) = sim;
while w / 2 >= crate::fluid::MG_COARSEST && h / 2 >= crate::fluid::MG_COARSEST && mg.len() < 8 {
w /= 2;
h /= 2;
mg.push(Level {
pressure: Pair::new(device, w, h, f.scalar)?,
rhs: field(device, w, h, f.scalar)?,
residual: field(device, w, h, f.scalar)?,
size: (w, h),
});
}
let mut bloom_chain = Vec::new();
for i in 0..c.bloom_iterations {
let (w, h) = (bloom.0 >> (i + 1), bloom.1 >> (i + 1));
if w < 2 || h < 2 {
break;
}
bloom_chain.push((field(device, w, h, f.dye)?, (w, h)));
}
Ok(Self {
sim,
dye_size,
velocity: Pair::new(device, sim.0, sim.1, f.velocity)?,
dye: Pair::new(device, dye_size.0, dye_size.1, f.dye)?,
pressure: Pair::new(device, sim.0, sim.1, f.scalar)?,
divergence: field(device, sim.0, sim.1, f.scalar)?,
curl: field(device, sim.0, sim.1, f.scalar)?,
scratch_velocity: field(device, sim.0, sim.1, f.velocity)?,
scratch_dye: field(device, dye_size.0, dye_size.1, f.dye)?,
residual: field(device, sim.0, sim.1, f.scalar)?,
mg,
bloom: (field(device, bloom.0, bloom.1, f.dye)?, bloom),
bloom_chain,
sunrays: (field(device, rays.0, rays.1, f.scalar)?, rays),
sunrays_temp: field(device, rays.0, rays.1, f.scalar)?,
})
}
fn all(&self) -> Vec<Id> {
let mut out = vec![
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(),
self.scratch_velocity.id(),
self.scratch_dye.id(),
self.residual.id(),
self.bloom.0.id(),
self.sunrays.0.id(),
self.sunrays_temp.id(),
];
for l in &self.mg {
out.extend([l.pressure.read.id(), l.pressure.write.id(), l.rhs.id(), l.residual.id()]);
}
out.extend(self.bloom_chain.iter().map(|(t, _)| t.id()));
out
}
}
fn texel_of(size: (u32, u32)) -> [f32; 2] {
[1.0 / size.0 as f32, 1.0 / size.1 as f32]
}
fn field(device: &MetalDevice, w: u32, h: u32, format: NSUInteger) -> 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,
clear_v: Owned,
clear_s: Owned,
splat: Owned,
splat_v: Owned,
advection: Owned,
advection_v: Owned,
advect_correct_v: Owned,
divergence: Owned,
curl: Owned,
vorticity: Owned,
pressure: Owned,
gradient: Owned,
advect_correct: Owned,
residual: Owned,
restrict: Owned,
prolong: Owned,
bloom_prefilter: Owned,
bloom_blur: Owned,
bloom_blur_add: Owned,
bloom_final: Owned,
sunrays_mask: Owned,
sunrays: Owned,
blur: Owned,
display: Vec<(NSUInteger, Owned)>,
display_over: Vec<(NSUInteger, Owned)>,
color: Vec<(NSUInteger, Owned)>,
overlay: Vec<(NSUInteger, Owned)>,
}
pub use crate::fluid::FluidSplat;
pub struct MetalFluid {
config: FluidConfig,
width: u32,
height: u32,
grids: Grids,
pipes: Pipelines,
rng: u64,
colour_timer: f32,
paused: bool,
pointers: crate::fluid::Pointers,
rate: Rate,
history: Owned,
formats: Formats,
}
impl MetalFluid {
pub fn new(
device: &MetalDevice,
width: u32,
height: u32,
config: FluidConfig,
) -> Result<Self, MetalError> {
Self::with_formats(device, width, height, config, MetalFieldFormats::Uniform)
}
pub fn with_formats(
device: &MetalDevice,
width: u32,
height: u32,
config: FluidConfig,
formats: MetalFieldFormats,
) -> Result<Self, MetalError> {
let f = Formats::from(formats);
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 p = |name: &str, format| fullscreen_pipeline_with(device, "fluid_vs", name, format);
let pipes = Pipelines {
clear: p("fluid_fs_clear", f.dye)?,
clear_v: p("fluid_fs_clear", f.velocity)?,
clear_s: p("fluid_fs_clear", f.scalar)?,
splat: p("fluid_fs_splat", f.dye)?,
splat_v: p("fluid_fs_splat", f.velocity)?,
advection: p("fluid_fs_advection", f.dye)?,
advection_v: p("fluid_fs_advection", f.velocity)?,
divergence: p("fluid_fs_divergence", f.scalar)?,
curl: p("fluid_fs_curl", f.scalar)?,
vorticity: p("fluid_fs_vorticity", f.velocity)?,
pressure: p("fluid_fs_pressure", f.scalar)?,
gradient: p("fluid_fs_gradient", f.velocity)?,
advect_correct: p("fluid_fs_advect_correct", f.dye)?,
advect_correct_v: p("fluid_fs_advect_correct", f.velocity)?,
residual: p("fluid_fs_residual", f.scalar)?,
restrict: p("fluid_fs_restriction", f.scalar)?,
prolong: p("fluid_fs_prolong", f.scalar)?,
bloom_prefilter: p("fluid_fs_bloom_prefilter", f.dye)?,
bloom_blur: p("fluid_fs_bloom_blur", f.dye)?,
bloom_blur_add: fullscreen_pipeline_blend(device, "fluid_vs", "fluid_fs_bloom_blur", f.dye, true)?,
bloom_final: p("fluid_fs_bloom_final", f.dye)?,
sunrays_mask: p("fluid_fs_sunrays_mask", f.dye)?,
sunrays: p("fluid_fs_sunrays", f.scalar)?,
blur: fullscreen_pipeline_with(device, "fluid_vs_blur", "fluid_fs_blur", f.scalar)?,
display: Vec::new(),
display_over: Vec::new(),
color: Vec::new(),
overlay: Vec::new(),
};
let fluid = Self {
grids: Grids::new(device, &config, f, width, height)?,
config,
width,
height,
pipes,
rng: config.seed | 1,
colour_timer: 0.0,
paused: false,
pointers: Default::default(),
rate: Rate::default(),
history: new_texture_2d(
device,
Frames::LEN as u32,
1,
pixel_format::RGBA8_UNORM,
texture_usage::SHADER_READ,
storage_mode::PRIVATE,
1,
1,
)?,
formats: f,
};
fluid.zero_fields(device)?;
Ok(fluid)
}
fn zero_fields(&self, device: &MetalDevice) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
let cmd = self.command_buffer(device);
self.zero_fields_on(cmd)?;
commit(cmd);
Ok(())
}
fn zero_fields_on(&self, cmd: Id) -> Result<(), MetalError> {
for t in self.grids.all() {
clear_to_zero(cmd, t)?;
}
Ok(())
}
pub fn config(&self) -> &FluidConfig {
&self.config
}
pub fn clear(&mut self, device: &MetalDevice) -> Result<(), MetalError> {
self.zero_fields(device)
}
pub fn clear_on(&mut self, cmd: Id) -> Result<(), MetalError> {
self.zero_fields_on(cmd)
}
pub fn dye_texture(&self) -> Id {
self.grids.dye.read.id()
}
pub fn size(&self) -> (u32, u32) {
(self.width, self.height)
}
pub fn grid_sizes(&self) -> ((u32, u32), (u32, u32)) {
(self.grids.dye_size, self.grids.sim)
}
pub fn set_paused(&mut self, paused: bool) {
self.paused = paused;
}
pub fn set_config(&mut self, device: &MetalDevice, config: FluidConfig) -> Result<(), MetalError> {
let resized = config.sim_resolution != self.config.sim_resolution
|| config.dye_resolution != self.config.dye_resolution
|| config.bloom_resolution != self.config.bloom_resolution
|| config.bloom_iterations != self.config.bloom_iterations
|| config.sunrays_resolution != self.config.sunrays_resolution;
self.config = config;
if resized {
self.reallocate(device)?;
}
Ok(())
}
pub fn resize(&mut self, device: &MetalDevice, width: u32, height: u32) -> Result<(), MetalError> {
let (width, height) = (width.max(1), height.max(1));
if (width, height) == (self.width, self.height) {
return Ok(());
}
self.width = width;
self.height = height;
self.reallocate(device)
}
fn reallocate(&mut self, device: &MetalDevice) -> Result<(), MetalError> {
let old = std::mem::replace(&mut self.grids, Grids::new(device, &self.config, self.formats, self.width, self.height)?);
self.zero_fields(device)?;
let _pool = AutoreleasePool::new();
let cmd = self.command_buffer(device);
let u = Params { value: 1.0, ..Default::default() };
for (src, dst, pipe) in [
(old.dye.read.id(), self.grids.dye.read.id(), &self.pipes.clear),
(old.velocity.read.id(), self.grids.velocity.read.id(), &self.pipes.clear_v),
] {
encode(cmd, pipe, dst, |enc| bind(enc, u, &[src]))?;
}
commit(cmd);
Ok(())
}
pub fn paused(&self) -> bool {
self.paused
}
pub fn pointer_down(&mut self, id: i32, x: f32, y: f32) {
let color = self.generate_color();
self.pointers.down(id, x / self.width as f32, y / self.height as f32, color);
}
pub fn pointer_move(&mut self, id: i32, x: f32, y: f32) {
let (w, h) = (self.width as f32, self.height as f32);
self.pointers.move_to(id, x / w, y / h, w / h);
}
pub fn pointer_up(&mut self, id: i32) {
self.pointers.up(id);
}
fn generate_color(&mut self) -> [f32; 3] {
let c = crate::fluid::hsv_to_rgb_for_backends(self.next_f32(), 1.0, 1.0);
[c[0] * 0.15, c[1] * 0.15, c[2] * 0.15]
}
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) {
let mut burst = Vec::with_capacity(count as usize);
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);
burst.push((x, y, dx, dy, colour));
}
let _ = self.splats(device, &burst);
}
pub fn splat(
&mut self,
device: &MetalDevice,
x: f32,
y: f32,
dx: f32,
dy: f32,
color: [f32; 3],
) -> Result<(), MetalError> {
self.splats(device, &[(x, y, dx, dy, color)])
}
fn splats(&mut self, device: &MetalDevice, list: &[(f32, f32, f32, f32, [f32; 3])]) -> Result<(), MetalError> {
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 list: Vec<FluidSplat> = list
.iter()
.map(|&(x, y, dx, dy, color)| FluidSplat { x, y, dx, dy, color, radius, erase: false })
.collect();
self.splat_batch(device, &list)
}
pub fn splat_batch(&mut self, device: &MetalDevice, list: &[FluidSplat]) -> Result<(), MetalError> {
if list.is_empty() {
return Ok(());
}
let _pool = AutoreleasePool::new();
let cmd = self.command_buffer(device);
self.splat_batch_on(cmd, list)?;
commit(cmd);
Ok(())
}
pub fn splat_batch_on(&mut self, cmd: Id, list: &[FluidSplat]) -> Result<(), MetalError> {
use crate::fluid::passes::MAX_BATCH;
let aspect = self.width as f32 / self.height as f32;
for chunk in list.chunks(MAX_BATCH) {
let _pool = AutoreleasePool::new();
let mut velocity = vec![0.0f32; chunk.len() * 8];
let mut dye = vec![0.0f32; chunk.len() * 8];
for (k, s) in chunk.iter().enumerate() {
for batch in [&mut velocity, &mut dye] {
batch[k * 8..k * 8 + 3].copy_from_slice(&[s.x, s.y, s.radius]);
}
velocity[k * 8 + 4..k * 8 + 6].copy_from_slice(&[s.dx, s.dy]);
dye[k * 8 + 4..k * 8 + 8].copy_from_slice(&[s.color[0], s.color[1], s.color[2], if s.erase { 1.0 } else { 0.0 }]);
}
let u = Params {
aspect_ratio: aspect,
value: chunk.len() as f32,
..Default::default()
};
for (field, batch, pipe) in [
(&self.grids.velocity, &velocity, &self.pipes.splat_v),
(&self.grids.dye, &dye, &self.pipes.splat),
] {
encode(cmd, pipe, field.write.id(), |enc| {
bind(enc, u, &[field.read.id()]);
bind_batch(enc, batch);
})?;
}
self.grids.velocity.swap();
self.grids.dye.swap();
}
Ok(())
}
pub fn update(&mut self, device: &MetalDevice, dt: f32) {
let dt = dt * self.config.time_scale.max(0.0);
if self.config.colorful {
self.colour_timer += dt * self.config.color_update_speed;
if self.colour_timer >= 1.0 {
self.colour_timer = self.colour_timer.fract();
let mut pointers = std::mem::take(&mut self.pointers);
pointers.recolor(|| self.generate_color());
self.pointers = pointers;
}
}
let moved = self.pointers.take_moved(self.config.splat_force);
let _ = self.splats(device, &moved);
if !self.paused && dt > 0.0 {
let _ = self.step(device, dt);
}
}
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 cmd = self.command_buffer(device);
self.step_on(cmd, dt)?;
commit(cmd);
Ok(())
}
pub fn step_on(&mut self, cmd: Id, dt: f32) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
let c = self.config;
let texel = [1.0 / self.grids.sim.0 as f32, 1.0 / self.grids.sim.1 as f32];
let plain = Params {
texel_size: texel,
..Default::default()
};
let u = plain;
encode(cmd, &self.pipes.curl, self.grids.curl.id(), |enc| {
bind(enc, u, &[self.grids.velocity.read.id()]);
})?;
let u = Params {
texel_size: texel,
dt,
curl: c.curl,
..Default::default()
};
encode(
cmd,
&self.pipes.vorticity,
self.grids.velocity.write.id(),
|enc| {
bind(enc, u, &[self.grids.velocity.read.id(), self.grids.curl.id()]);
},
)?;
self.grids.velocity.swap();
let u = plain;
encode(cmd, &self.pipes.divergence, self.grids.divergence.id(), |enc| {
bind(enc, u, &[self.grids.velocity.read.id()]);
})?;
let u = Params {
value: c.pressure,
..Default::default()
};
encode(cmd, &self.pipes.clear_s, self.grids.pressure.write.id(), |enc| {
bind(enc, u, &[self.grids.pressure.read.id()]);
})?;
self.grids.pressure.swap();
match c.pressure_solver {
PressureSolver::Jacobi => self.jacobi(cmd, None, c.pressure_iterations, 1.0)?,
PressureSolver::Multigrid => self.multigrid(cmd)?,
}
let u = Params {
texel_size: texel,
value: c.gradient_scale,
..Default::default()
};
encode(cmd, &self.pipes.gradient, self.grids.velocity.write.id(), |enc| {
bind(enc, u, &[self.grids.pressure.read.id(), self.grids.velocity.read.id()]);
})?;
self.grids.velocity.swap();
self.advect(cmd, dt, texel, true)?;
self.advect(cmd, dt, texel, false)?;
Ok(())
}
fn advect(&mut self, cmd: Id, dt: f32, texel: [f32; 2], velocity_field: bool) -> Result<(), MetalError> {
let c = self.config;
let maccormack = c.advection == Advection::MacCormack;
let dissipation = if velocity_field { c.velocity_dissipation } else { c.density_dissipation };
let g = &self.grids;
let (field, scratch, size) = if velocity_field {
(&g.velocity, g.scratch_velocity.id(), g.sim)
} else {
(&g.dye, g.scratch_dye.id(), g.dye_size)
};
let (velocity, src, fwd) = (g.velocity.read.id(), field.read.id(), field.write.id());
let params = Params {
texel_size: texel,
dye_texel_size: texel_of(size),
dt,
dissipation: if maccormack { 0.0 } else { dissipation },
..Default::default()
};
let u = params;
let (advection, correct) = if velocity_field {
(&self.pipes.advection_v, &self.pipes.advect_correct_v)
} else {
(&self.pipes.advection, &self.pipes.advect_correct)
};
encode(cmd, advection, fwd, |enc| bind(enc, u, &[velocity, src]))?;
if maccormack {
let u = Params { dissipation, ..params };
encode(cmd, correct, scratch, |enc| bind(enc, u, &[velocity, fwd, src]))?;
}
let g = &mut self.grids;
match (velocity_field, maccormack) {
(true, false) => g.velocity.swap(),
(false, false) => g.dye.swap(),
(true, true) => std::mem::swap(&mut g.velocity.read, &mut g.scratch_velocity),
(false, true) => std::mem::swap(&mut g.dye.read, &mut g.scratch_dye),
}
Ok(())
}
fn jacobi(&mut self, cmd: Id, level: Option<usize>, count: u32, weight: f32) -> Result<(), MetalError> {
let (size, rhs) = match level {
None => (self.grids.sim, self.grids.divergence.id()),
Some(l) => (self.grids.mg[l].size, self.grids.mg[l].rhs.id()),
};
let u = Params {
texel_size: texel_of(size),
value: weight,
..Default::default()
};
let pair = match level {
None => &mut self.grids.pressure,
Some(l) => &mut self.grids.mg[l].pressure,
};
for i in 0..count {
let (src, dst) = if i % 2 == 0 {
(pair.read.id(), pair.write.id())
} else {
(pair.write.id(), pair.read.id())
};
encode(cmd, &self.pipes.pressure, dst, |enc| bind(enc, u, &[src, rhs]))?;
}
if count % 2 == 1 {
pair.swap();
}
Ok(())
}
fn multigrid(&mut self, cmd: Id) -> Result<(), MetalError> {
use crate::fluid::MG_WEIGHT;
let n = self.grids.mg.len();
if n == 0 {
return self.jacobi(cmd, None, self.config.pressure_iterations, 1.0);
}
let nu = 2;
let coarse_sweeps = self.config.pressure_iterations.max(nu * 2);
for _ in 0..self.config.multigrid_cycles.max(1) {
self.jacobi(cmd, None, nu, MG_WEIGHT)?;
for level in 0..n {
let g = &self.grids;
let (pressure, rhs, fine, residual) = if level == 0 {
(g.pressure.read.id(), g.divergence.id(), g.sim, g.residual.id())
} else {
let l = &g.mg[level - 1];
(l.pressure.read.id(), l.rhs.id(), l.size, l.residual.id())
};
let coarse = (g.mg[level].rhs.id(), g.mg[level].pressure.read.id());
let u = Params { texel_size: texel_of(fine), ..Default::default() };
encode(cmd, &self.pipes.residual, residual, |enc| bind(enc, u, &[pressure, rhs]))?;
let u = Params { texel_size: texel_of(fine), ..Default::default() };
encode(cmd, &self.pipes.restrict, coarse.0, |enc| bind(enc, u, &[residual]))?;
clear_to_zero(cmd, coarse.1)?;
let sweeps = if level + 1 == n { coarse_sweeps } else { nu };
self.jacobi(cmd, Some(level), sweeps, MG_WEIGHT)?;
}
for level in (0..n).rev() {
let correction = self.grids.mg[level].pressure.read.id();
let u = Params::default();
let fine = if level == 0 {
&mut self.grids.pressure
} else {
&mut self.grids.mg[level - 1].pressure
};
let (src, dst) = (fine.read.id(), fine.write.id());
encode(cmd, &self.pipes.prolong, dst, |enc| bind(enc, u, &[correction, src]))?;
fine.swap();
self.jacobi(cmd, level.checked_sub(1), nu, MG_WEIGHT)?;
}
}
Ok(())
}
pub fn render(
&mut self,
device: &MetalDevice,
target: Id,
format: NSUInteger,
size: (u32, u32),
) -> Result<(), MetalError> {
self.composite(device, target, format, size, std::ptr::null_mut())
}
pub fn render_on(
&mut self,
device: &MetalDevice,
cmd: Id,
target: Id,
format: NSUInteger,
size: (u32, u32),
) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
self.composite_on(device, cmd, target, format, size)?;
self.rate.tick();
Ok(())
}
#[cfg(metal_backend)]
pub fn present(&mut self, device: &MetalDevice, frame: &crate::metal::SurfaceFrame) -> Result<(), MetalError> {
let a = frame.attachments();
let target = if a.resolve.is_null() { a.color } else { a.resolve };
self.composite(device, target, a.color_format, (a.width, a.height), a.drawable)
}
fn composite(
&mut self,
device: &MetalDevice,
target: Id,
format: NSUInteger,
size: (u32, u32),
drawable: Id,
) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
let cmd = self.command_buffer(device);
self.composite_on(device, cmd, target, format, size)?;
if !drawable.is_null() {
unsafe {
let _: () = msg1(cmd, sel!("presentDrawable:"), drawable);
}
}
commit(cmd);
self.rate.tick();
Ok(())
}
fn composite_on(
&mut self,
device: &MetalDevice,
cmd: Id,
target: Id,
format: NSUInteger,
size: (u32, u32),
) -> Result<(), MetalError> {
self.ensure_output_pipelines(device, format)?;
let c = self.config;
if c.bloom {
self.bloom(cmd)?;
}
if c.sunrays {
self.sunrays(cmd)?;
}
let encode_srgb = if pixel_format::is_srgb(format) {
FLAG_ENCODE
} else {
0
};
let (w, h) = (size.0.max(1), size.1.max(1));
if !c.transparent {
let u = 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.grids.dye.read.id()]);
})?;
}
let mut flags = encode_srgb;
if c.shading {
flags |= FLAG_SHADING;
}
if c.bloom {
flags |= FLAG_BLOOM;
}
if c.sunrays {
flags |= FLAG_SUNRAYS;
}
let u = 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)
};
let textures = [self.grids.dye.read.id(), self.grids.bloom.0.id(), self.grids.sunrays.0.id()];
encode_over(cmd, pipeline, target, over, |enc| {
bind(enc, u, &textures);
})?;
if c.show_fps {
let row = device.new_buffer(&self.rate.frames().row())?;
blit_row_to_texture(cmd, &row, &self.history, Frames::LEN as u32)?;
let u = 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()]);
})?;
}
Ok(())
}
fn bloom(&mut self, cmd: Id) -> Result<(), MetalError> {
if self.grids.bloom_chain.len() < 2 {
return Ok(());
}
let c = self.config;
let knee = c.bloom_threshold * c.bloom_soft_knee + 0.0001;
let u = Params {
curve: [c.bloom_threshold - knee, knee * 2.0, 0.25 / knee, c.bloom_threshold],
..Default::default()
};
let (dye, bloom) = (self.grids.dye.read.id(), self.grids.bloom.0.id());
encode(cmd, &self.pipes.bloom_prefilter, bloom, |enc| bind(enc, u, &[dye]))?;
let chain: Vec<(Id, (u32, u32))> = self.grids.bloom_chain.iter().map(|(t, s)| (t.id(), *s)).collect();
let mut last = (bloom, self.grids.bloom.1);
for &dest in &chain {
let u = Params { texel_size: texel_of(last.1), ..Default::default() };
encode(cmd, &self.pipes.bloom_blur, dest.0, |enc| bind(enc, u, &[last.0]))?;
last = dest;
}
for &base in chain[..chain.len() - 1].iter().rev() {
let u = Params { texel_size: texel_of(last.1), ..Default::default() };
encode_over(cmd, &self.pipes.bloom_blur_add, base.0, true, |enc| bind(enc, u, &[last.0]))?;
last = base;
}
let u = Params {
texel_size: texel_of(last.1),
value: c.bloom_intensity,
..Default::default()
};
encode(cmd, &self.pipes.bloom_final, bloom, |enc| bind(enc, u, &[last.0]))
}
fn sunrays(&mut self, cmd: Id) -> Result<(), MetalError> {
let g = &self.grids;
let (dye, mask, rays, temp, size) =
(g.dye.read.id(), g.dye.write.id(), g.sunrays.0.id(), g.sunrays_temp.id(), g.sunrays.1);
let u = Params::default();
encode(cmd, &self.pipes.sunrays_mask, mask, |enc| bind(enc, u, &[dye]))?;
let u = Params { value: self.config.sunrays_weight, ..Default::default() };
encode(cmd, &self.pipes.sunrays, rays, |enc| bind(enc, u, &[mask]))?;
let t = texel_of(size);
let u = Params { texel_size: [t[0], 0.0], ..Default::default() };
encode(cmd, &self.pipes.blur, temp, |enc| bind(enc, u, &[rays]))?;
let u = Params { texel_size: [0.0, t[1]], ..Default::default() };
encode(cmd, &self.pipes.blur, rays, |enc| bind(enc, u, &[temp]))
}
pub fn fps(&self) -> f32 {
self.rate.fps()
}
#[cfg(metal_backend)]
pub fn capture_rgba(&mut self, device: &MetalDevice) -> Result<Vec<u8>, MetalError> {
let _pool = AutoreleasePool::new();
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 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, "fluid_vs", "fluid_fs_display", format)?;
self.pipes.display.push((format, p));
}
if !self.pipes.display_over.iter().any(|(f, _)| *f == format) {
let p =
fullscreen_pipeline_blend(device, "fluid_vs", "fluid_fs_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, "fluid_vs", "fluid_fs_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, "fluid_vs", "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: Params, textures: &[Id]) {
let bytes = bytemuck::bytes_of(¶ms);
unsafe {
let _: () = msg3(enc, sel!("setFragmentBytes:length:atIndex:"), bytes.as_ptr(), bytes.len(), 0usize);
let _: () = msg3(enc, sel!("setVertexBytes:length:atIndex:"), bytes.as_ptr(), bytes.len(), 0usize);
for (i, t) in textures.iter().enumerate() {
let _: () = msg2(enc, sel!("setFragmentTexture:atIndex:"), *t, i);
}
}
}
fn bind_batch(enc: Id, batch: &[f32]) {
unsafe {
let _: () = msg3(enc, sel!("setFragmentBytes:length:atIndex:"), batch.as_ptr(), batch.len() * 4, 1usize);
}
}
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 = 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(())
}
pub(super) fn clear_to_zero(cmd: Id, dst: Id) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
unsafe {
let desc = 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(())
}
pub(super) fn blit_row_to_texture(cmd: Id, buffer: &Owned, texture: &Owned, width: u32) -> Result<(), MetalError> {
unsafe {
let blit: Id = msg0(cmd, sel!("blitCommandEncoder"));
if blit.is_null() {
return Err(MetalError::Unsupported("fluid: no blit encoder for the read-out".into()));
}
let _: () = super::objc::msg9(
blit,
sel!(
"copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:"
),
buffer.id(),
0usize,
(width * 4) as NSUInteger,
(width * 4) as NSUInteger,
MTLSize { width: width as NSUInteger, height: 1, depth: 1 },
texture.id(),
0usize,
0usize,
MTLOrigin::default(),
);
let _: () = msg0(blit, sel!("endEncoding"));
}
Ok(())
}
pub(super) fn commit(cmd: Id) {
unsafe {
let _: () = msg0(cmd, sel!("commit"));
}
}
#[cfg(all(test, metal_backend, feature = "fluid"))]
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,
"fluid_vs",
"fluid_fs_clear",
pixel_format::RGBA8_UNORM,
)
.unwrap();
let cmd = fluid.command_buffer(device);
let u = 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.as_chunks::<4>()
.0
.iter()
.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()
};
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
.as_chunks::<4>()
.0
.iter()
.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.grids.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 a_drag_paints_under_the_pointer() {
let Some(device) = device() else { return };
let mut fluid = MetalFluid::new(&device, 256, 256, FluidConfig::default()).unwrap();
fluid.set_paused(true);
fluid.pointer_move(-1, 200.0, 200.0);
fluid.update(&device, 1.0 / 60.0);
let src = fluid.grids.dye.read.id();
assert_eq!(brightest(&dump(&mut fluid, &device, src)), 0, "a hovering pointer painted");
fluid.pointer_down(-1, 40.0, 40.0);
for k in 1..=10 {
fluid.pointer_move(-1, 40.0 + 6.0 * k as f32, 50.0);
fluid.update(&device, 1.0 / 60.0);
}
fluid.pointer_up(-1);
let src = fluid.grids.dye.read.id();
let dye = dump(&mut fluid, &device, src);
let quadrant = |x0: usize, y0: usize| {
(y0..y0 + 64)
.flat_map(|y| (x0..x0 + 64).map(move |x| (y, x)))
.map(|(y, x)| {
let p = &dye[(y * 128 + x) * 4..][..3];
p[0].max(p[1]).max(p[2])
})
.max()
.unwrap()
};
assert!(quadrant(0, 0) > 10, "the drag left no dye under it ({})", quadrant(0, 0));
assert_eq!(quadrant(64, 64), 0, "dye away from the drag");
}
#[test]
fn resize_and_set_config_rebuild_the_grids() {
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();
fluid.resize(&device, 512, 256).unwrap();
let ((dw, dh), (sw, sh)) = fluid.grid_sizes();
assert_eq!((dw, dh, sw, sh), (dw.max(dh), dw.min(dh), sw.max(sh), sw.min(sh)), "landscape grids");
assert_eq!(dw, 2 * dh);
let c = FluidConfig {
dye_resolution: 256,
..*fluid.config()
};
fluid.set_config(&device, c).unwrap();
assert_eq!(fluid.grid_sizes().0, (512, 256));
let src = fluid.grids.dye.read.id();
assert!(brightest(&dump(&mut fluid, &device, src)) > 100, "the resize wiped the 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.grids.dye.read.id();
let dye = dump(&mut fluid, &device, src);
assert!(
brightest(&dye) > 100,
"ten steps erased the dye (brightest {})",
brightest(&dye)
);
}
#[test]
fn narrow_formats_keep_the_dye_and_the_picture() {
let Some(device) = device() else { return };
let config = FluidConfig { bloom: false, sunrays: false, colorful: false, ..FluidConfig::default() };
let run = |formats| {
let mut fluid = MetalFluid::with_formats(&device, 256, 256, config, formats).unwrap();
fluid.splat(&device, 0.5, 0.5, 300.0, -200.0, [1.0, 0.5, 0.25]).unwrap();
for _ in 0..10 {
fluid.update(&device, 1.0 / 60.0);
}
fluid.capture_rgba(&device).unwrap()
};
let (wide, narrow) = (run(MetalFieldFormats::Uniform), run(MetalFieldFormats::Narrow));
assert!(brightest(&narrow) > 100, "narrow formats lost the dye (brightest {})", brightest(&narrow));
let mean = wide.iter().zip(&narrow).map(|(a, b)| (*a as i32 - *b as i32).abs() as f64).sum::<f64>()
/ wide.len() as f64;
assert!(mean < 1.0, "narrow formats drew a different fluid (mean |diff| {mean:.3}/255)");
}
#[test]
fn the_on_methods_draw_what_the_committing_ones_draw() {
let Some(device) = device() else { return };
let config = FluidConfig { bloom: false, sunrays: false, colorful: false, ..FluidConfig::default() };
let splats = [
FluidSplat { x: 0.3, y: 0.4, dx: 400.0, dy: 0.0, color: [1.0, 0.2, 0.1], radius: 0.003, erase: false },
FluidSplat { x: 0.6, y: 0.6, dx: 0.0, dy: -300.0, color: [0.1, 0.4, 1.0], radius: 0.003, erase: false },
];
let mut a = MetalFluid::new(&device, 256, 256, config).unwrap();
let mut b = MetalFluid::new(&device, 256, 256, config).unwrap();
for _ in 0..5 {
a.splat_batch(&device, &splats).unwrap();
a.step(&device, 1.0 / 60.0).unwrap();
let cmd = device.command_buffer();
b.splat_batch_on(cmd, &splats).unwrap();
b.step_on(cmd, 1.0 / 60.0).unwrap();
commit(cmd);
}
let (ra, rb) = (a.capture_rgba(&device).unwrap(), b.capture_rgba(&device).unwrap());
assert!(brightest(&ra) > 50);
assert_eq!(ra, rb, "one buffer and many drew different fluids");
let cmd = device.command_buffer();
b.clear_on(cmd).unwrap();
commit(cmd);
assert_eq!(brightest(&b.capture_rgba(&device).unwrap()), 0, "clear_on left dye behind");
}
#[test]
fn an_eraser_takes_dye_away_and_clear_empties_it() {
let Some(device) = device() else { return };
let mut fluid = MetalFluid::new(&device, 256, 256, FluidConfig::default()).unwrap();
let paint = FluidSplat { x: 0.5, y: 0.5, color: [1.0, 0.5, 0.25], radius: 0.0025, ..Default::default() };
fluid.splat_batch(&device, &[paint]).unwrap();
let src = fluid.dye_texture();
let before = brightest(&dump(&mut fluid, &device, src));
assert!(before > 100, "the paint did not land (brightest {before})");
let erase = FluidSplat { color: [4.0, 4.0, 4.0], erase: true, ..paint };
fluid.splat_batch(&device, &[erase]).unwrap();
let src = fluid.dye_texture();
let after = brightest(&dump(&mut fluid, &device, src));
assert!(after < before / 4, "the eraser left the dye ({before} → {after})");
fluid.splat_batch(&device, &[paint]).unwrap();
fluid.clear(&device).unwrap();
let src = fluid.dye_texture();
assert_eq!(brightest(&dump(&mut fluid, &device, src)), 0, "clear left dye behind");
}
#[test]
#[cfg_attr(not(feature = "fluid"), ignore)]
fn metal_fluid_matches_wgpu() {
let config = FluidConfig {
bloom: false,
sunrays: false,
colorful: false,
..FluidConfig::default()
};
if let Some(mean) = parity(config) {
assert!(mean < 0.05, "the two backends drew different fluids (mean |diff| {mean:.3}/255)");
}
}
#[test]
#[cfg_attr(not(feature = "fluid"), ignore)]
fn bloom_sunrays_maccormack_and_multigrid_match_wgpu() {
use crate::fluid::{Advection, PressureSolver};
let base = FluidConfig {
bloom: false,
sunrays: false,
colorful: false,
..FluidConfig::default()
};
let cases = [
("bloom", FluidConfig { bloom: true, ..base }),
("sunrays", FluidConfig { sunrays: true, ..base }),
("maccormack", FluidConfig { advection: Advection::MacCormack, ..base }),
("multigrid", FluidConfig { pressure_solver: PressureSolver::Multigrid, ..base }),
(
"everything",
FluidConfig {
bloom: true,
sunrays: true,
advection: Advection::MacCormack,
pressure_solver: PressureSolver::Multigrid,
..base
},
),
];
let mut failures = Vec::new();
for (name, config) in cases {
let Some(mean) = parity(config) else { return };
eprintln!("{name}: mean |diff| {mean:.3}/255");
if mean >= 0.05 {
failures.push(format!("{name}: mean |diff| {mean:.2}/255"));
}
}
assert!(failures.is_empty(), "{}", failures.join("\n"));
}
fn parity(config: FluidConfig) -> Option<f64> {
use crate::gpu::GpuContext;
let device = device()?;
let Ok(gpu) = GpuContext::headless_blocking() else {
eprintln!("skipping: no wgpu adapter");
return None;
};
let (w, h) = (320, 192);
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");
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());
Some(a.iter().zip(&b).map(|(x, y)| x.abs_diff(*y) as f64).sum::<f64>() / a.len() as f64)
}
#[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.as_chunks::<4>().0.iter().all(|p| p[3] == 255),
"the picture is not opaque"
);
assert!(
rgba.as_chunks::<4>()
.0
.iter()
.all(|p| p[0] > 0 && p[2] > p[0]),
"the background colour is not in the picture"
);
}
}