use std::collections::HashMap;
use super::device::{compile_library, MetalDevice, MetalError};
use super::enums::*;
use super::fluid::{blit_row_to_texture, clear_to_zero, commit};
use super::objc::{
alloc_init, class, error_message, msg0, msg1, msg2, msg3, nsstring, sel, AutoreleasePool, Id,
Owned, NIL, YES,
};
use super::pass::new_texture_2d;
use crate::cameras::Camera;
use crate::fluid::read_out::{Frames, Rate};
use crate::fluid::volume_config::{self, Atlas, FluidConfig3d, Vol, MG_COARSEST_3D};
use crate::fluid::{PressureSolver, Rng};
const VEC: NSUInteger = pixel_format::RGBA16_FLOAT;
const DYE: NSUInteger = pixel_format::RGBA16_FLOAT;
const SCALAR: NSUInteger = pixel_format::R16_FLOAT;
const BYTES: [u64; 3] = [8, 8, 2];
pub fn pixel_format_rgba8() -> NSUInteger {
pixel_format::RGBA8_UNORM
}
const VS: &str = crate::wgsl!(
r#"
struct FullscreenVertex {
@builtin(position) clip : vec4<f32>,
@location(0) uv : vec2<f32>,
};
@vertex
fn vs_main(@builtin(vertex_index) vid : u32) -> FullscreenVertex {
let x = f32((vid << 1u) & 2u);
let y = f32(vid & 2u);
var out : FullscreenVertex;
out.uv = vec2<f32>(x, y);
out.clip = vec4<f32>(x * 2.0 - 1.0, 1.0 - y * 2.0, 0.0, 1.0);
return out;
}
"#
);
pub fn fluid3d_shader_source() -> Result<(String, HashMap<String, String>), MetalError> {
use naga::back::msl;
let wgsl = format!(
"{VS}\n{}\n{}",
crate::fluid::read_out::glyphs(),
crate::fluid::volume_shader::SHADER
);
let fail =
|what: &str, e: String| MetalError::ShaderCompilation(format!("fluid3d {what}: {e}"));
let module =
naga::front::wgsl::parse_str(&wgsl).map_err(|e| fail("parse", e.emit_to_string(&wgsl)))?;
let info = naga::valid::Validator::new(
naga::valid::ValidationFlags::all(),
naga::valid::Capabilities::all(),
)
.validate(&module)
.map_err(|e| fail("validate", format!("{e:?}")))?;
let binding = |b: u32| naga::ResourceBinding {
group: 0,
binding: b,
};
let mut resources = msl::BindingMap::new();
resources.insert(
binding(0),
msl::BindTarget {
buffer: Some(0),
..Default::default()
},
);
resources.insert(
binding(1),
msl::BindTarget {
texture: Some(0),
..Default::default()
},
);
resources.insert(
binding(2),
msl::BindTarget {
texture: Some(1),
..Default::default()
},
);
resources.insert(
binding(4),
msl::BindTarget {
texture: Some(2),
..Default::default()
},
);
resources.insert(
binding(3),
msl::BindTarget {
sampler: Some(msl::BindSamplerTarget::Inline(0)),
..Default::default()
},
);
let per_entry_point_map = module
.entry_points
.iter()
.map(|ep| {
(
ep.name.clone(),
msl::EntryPointResources {
resources: resources.clone(),
..Default::default()
},
)
})
.collect();
let options = msl::Options {
lang_version: (2, 4),
per_entry_point_map,
inline_samplers: vec![msl::sampler::InlineSampler {
coord: msl::sampler::Coord::Normalized,
address: [msl::sampler::Address::ClampToEdge; 3],
border_color: msl::sampler::BorderColor::TransparentBlack,
mag_filter: msl::sampler::Filter::Linear,
min_filter: msl::sampler::Filter::Linear,
mip_filter: None,
lod_clamp: None,
max_anisotropy: None,
compare_func: msl::sampler::CompareFunc::Never,
}],
fake_missing_bindings: false,
bounds_check_policies: naga::proc::BoundsCheckPolicies {
index: naga::proc::BoundsCheckPolicy::Restrict,
buffer: naga::proc::BoundsCheckPolicy::Restrict,
image_load: naga::proc::BoundsCheckPolicy::Restrict,
binding_array: naga::proc::BoundsCheckPolicy::Unchecked,
},
..Default::default()
};
let (source, translated) =
msl::write_string(&module, &info, &options, &msl::PipelineOptions::default())
.map_err(|e| fail("translate", format!("{e:?}")))?;
let mut names = HashMap::new();
for (ep, name) in module.entry_points.iter().zip(translated.entry_point_names) {
let name = name.map_err(|e| fail("entry point", format!("{}: {e:?}", ep.name)))?;
names.insert(ep.name.clone(), name);
}
Ok((source, names))
}
struct Pair {
read: Owned,
write: Owned,
}
impl Pair {
fn new(device: &MetalDevice, atlas: Atlas, format: NSUInteger) -> Result<Self, MetalError> {
Ok(Self {
read: field(device, atlas, format)?,
write: field(device, atlas, format)?,
})
}
fn swap(&mut self) {
std::mem::swap(&mut self.read, &mut self.write);
}
}
fn field(device: &MetalDevice, atlas: Atlas, format: NSUInteger) -> Result<Owned, MetalError> {
let (w, h) = atlas.size();
texture(device, w, h, format)
}
fn texture(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 Level {
atlas: Atlas,
pressure: Pair,
rhs: Owned,
residual: Owned,
}
struct Fields {
velocity: Pair,
dye: Pair,
pressure: Pair,
divergence: Owned,
curl: Owned,
residual: Owned,
mg: Vec<Level>,
occupancy: [(Atlas, Owned); 2],
}
impl Fields {
fn new(
device: &MetalDevice,
c: &FluidConfig3d,
sim: Atlas,
dye: Atlas,
) -> Result<Self, MetalError> {
let mut mg = Vec::new();
let mut n = sim.grid;
let coarsest = c.multigrid_coarsest.max(MG_COARSEST_3D);
while n / 2 >= coarsest && mg.len() < 6 {
n /= 2;
let atlas = Atlas::new(n);
mg.push(Level {
atlas,
pressure: Pair::new(device, atlas, SCALAR)?,
rhs: field(device, atlas, SCALAR)?,
residual: field(device, atlas, SCALAR)?,
});
}
let level = |n: u32| -> Result<(Atlas, Owned), MetalError> {
let atlas = Atlas::new(n.max(2));
Ok((atlas, field(device, atlas, SCALAR)?))
};
Ok(Self {
velocity: Pair::new(device, sim, VEC)?,
dye: Pair::new(device, dye, DYE)?,
pressure: Pair::new(device, sim, SCALAR)?,
divergence: field(device, sim, SCALAR)?,
curl: field(device, sim, VEC)?,
residual: field(device, sim, SCALAR)?,
mg,
occupancy: [level(dye.grid / 2)?, level(dye.grid / 4)?],
})
}
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.residual.id(),
self.occupancy[0].1.id(),
self.occupancy[1].1.id(),
];
for l in &self.mg {
out.extend([
l.pressure.read.id(),
l.pressure.write.id(),
l.rhs.id(),
l.residual.id(),
]);
}
out
}
}
struct Pipes {
fill: Owned,
buoyancy: Owned,
splat_velocity: Owned,
splat_dye: Owned,
advect_velocity: Owned,
advect_dye: Owned,
divergence: Owned,
curl: Owned,
vorticity: Owned,
pressure: Owned,
gradient: Owned,
maxdown: Owned,
residual: Owned,
restrict: Owned,
prolong: Owned,
}
struct Accum {
size: (u32, u32),
current: Owned,
depth: Owned,
history: Pair,
}
pub struct MetalFluid3d {
config: FluidConfig3d,
sim: Atlas,
dye_atlas: Atlas,
fields: Fields,
occupancy_stale: bool,
library: Owned,
names: HashMap<String, String>,
vertex: Owned,
pipes: Pipes,
march: Vec<(NSUInteger, Owned)>,
resolve: Vec<(NSUInteger, Owned)>,
overlay: Vec<(NSUInteger, Owned)>,
accum_march: Option<Owned>,
accum: Option<Accum>,
view_proj: [f32; 16],
view_proj_inverse: [f32; 16],
accum_from: Option<[f32; 16]>,
accum_frame: u32,
rate: Rate,
history: Owned,
last_step: Option<Owned>,
solver_ms: f32,
passes: std::cell::Cell<u32>,
rng: Rng,
paused: bool,
#[cfg_attr(not(metal_backend), allow(dead_code))]
over: Option<(Owned, u32, u32)>,
}
enum Targets<'a> {
One(Id),
Many(&'a [Id]),
}
impl MetalFluid3d {
pub fn new(device: &MetalDevice, config: FluidConfig3d) -> Result<Self, MetalError> {
if config.pressure_iterations == 0 {
return Err(MetalError::Unsupported(
"fluid3d: pressure_iterations must be at least 1".into(),
));
}
let _pool = AutoreleasePool::new();
let (source, names) = fluid3d_shader_source()?;
let library = unsafe { compile_library(device.device_id(), &source)? };
let vertex = function(&library, &names, "vs_main")?;
let max = max_texture_side(device);
let sim = Atlas::largest_within(config.resolution, max);
let dye_atlas = Atlas::largest_within(config.dye_resolution, max);
let p = |fs: &str, format: NSUInteger| -> Result<Owned, MetalError> {
pipeline(
device,
&vertex,
&function(&library, &names, fs)?,
&[format],
false,
)
};
let pipes = Pipes {
fill: p("fs_fill3", VEC)?,
buoyancy: p("fs_buoyancy3", VEC)?,
splat_velocity: p("fs_splat3", VEC)?,
splat_dye: p("fs_splat3", DYE)?,
advect_velocity: p("fs_advect3_self", VEC)?,
advect_dye: p("fs_advect3", DYE)?,
divergence: p("fs_divergence3", SCALAR)?,
curl: p("fs_curl3", VEC)?,
vorticity: p("fs_vorticity3", VEC)?,
pressure: p("fs_pressure3", SCALAR)?,
gradient: p("fs_gradient3", VEC)?,
maxdown: p("fs_maxdown3", SCALAR)?,
residual: p("fs_residual3", SCALAR)?,
restrict: p("fs_restrict3", SCALAR)?,
prolong: p("fs_prolong3", SCALAR)?,
};
let fluid = Self {
fields: Fields::new(device, &config, sim, dye_atlas)?,
occupancy_stale: true,
library,
names,
vertex,
pipes,
march: Vec::new(),
resolve: Vec::new(),
overlay: Vec::new(),
accum_march: None,
accum: None,
view_proj: [0.0; 16],
view_proj_inverse: [0.0; 16],
accum_from: None,
accum_frame: 0,
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,
)?,
last_step: None,
solver_ms: 0.0,
passes: std::cell::Cell::new(0),
rng: Rng::new(config.seed),
paused: false,
over: None,
config,
sim,
dye_atlas,
};
fluid.clear_fields(device)?;
Ok(fluid)
}
fn clear_fields(&self, device: &MetalDevice) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
let cmd = device.command_buffer();
for t in self.fields.all() {
clear_to_zero(cmd, t)?;
}
commit(cmd);
Ok(())
}
pub fn config(&self) -> &FluidConfig3d {
&self.config
}
pub fn set_config(
&mut self,
device: &MetalDevice,
config: FluidConfig3d,
) -> Result<(), MetalError> {
let rebuild = config.resolution != self.config.resolution
|| config.dye_resolution != self.config.dye_resolution
|| config.multigrid_coarsest != self.config.multigrid_coarsest;
self.config = config;
if rebuild {
let max = max_texture_side(device);
self.sim = Atlas::largest_within(config.resolution.max(2), max);
self.dye_atlas = Atlas::largest_within(config.dye_resolution.max(2), max);
self.fields = Fields::new(device, &self.config, self.sim, self.dye_atlas)?;
self.occupancy_stale = true;
self.clear_fields(device)?;
}
Ok(())
}
pub fn grids(&self) -> (u32, u32) {
(self.sim.grid, self.dye_atlas.grid)
}
pub fn memory_bytes(&self) -> u64 {
Self::memory_for(self.sim.grid, self.dye_atlas.grid)
}
pub fn memory_for(resolution: u32, dye_resolution: u32) -> u64 {
volume_config::memory_bytes(resolution, dye_resolution, BYTES)
}
pub fn within_memory(budget: u64, ratio: u32) -> (u32, u32) {
volume_config::within_bytes(budget, ratio, BYTES)
}
pub fn paused(&self) -> bool {
self.paused
}
pub fn set_paused(&mut self, paused: bool) {
self.paused = paused;
}
pub fn passes_per_step(&self) -> u32 {
self.passes.get()
}
pub fn solver_ms(&mut self) -> f32 {
if let Some(cmd) = &self.last_step {
let status: NSUInteger = unsafe { msg0(cmd.id(), sel!("status")) };
if status == 4 {
let start: f64 = unsafe { msg0(cmd.id(), sel!("GPUStartTime")) };
let end: f64 = unsafe { msg0(cmd.id(), sel!("GPUEndTime")) };
self.solver_ms = ((end - start) * 1000.0).max(0.0) as f32;
self.last_step = None;
}
}
self.solver_ms
}
pub fn fps(&self) -> f32 {
self.rate.fps()
}
pub fn dye_texture(&self) -> Id {
self.fields.dye.read.id()
}
pub fn dye_atlas(&self) -> Atlas {
self.dye_atlas
}
pub fn splat(
&mut self,
device: &MetalDevice,
at: [f32; 3],
velocity: [f32; 3],
color: [f32; 3],
) -> Result<(), MetalError> {
self.splat_batch(device, &[(at, velocity, color)])
}
pub fn impulse_at_screen(
&mut self,
device: &MetalDevice,
camera: &dyn Camera,
uv: [f32; 2],
drag: [f32; 2],
strength: f32,
colour: [f32; 3],
) -> Result<(), MetalError> {
match volume_config::impulse(&self.config, self.sim.grid, camera, uv, drag, strength) {
Some((at, velocity)) => self.splat(device, at, velocity, colour),
None => Ok(()),
}
}
pub fn multiple_splats(&mut self, device: &MetalDevice, count: u32) -> Result<(), MetalError> {
let batch = volume_config::random_splats(&mut self.rng, count);
self.splat_batch(device, &batch)
}
pub fn splat_batch(
&mut self,
device: &MetalDevice,
splats: &[([f32; 3], [f32; 3], [f32; 3])],
) -> Result<(), MetalError> {
if splats.is_empty() {
return Ok(());
}
let _pool = AutoreleasePool::new();
let radius = self.config.splat_radius / 100.0;
let cmd = device.command_buffer();
for (at, vel, color) in splats {
for dye in [false, true] {
let (atlas, value) = if dye {
(self.dye_atlas, *color)
} else {
(self.sim, *vel)
};
let u = self.params(
atlas,
Vol {
point: [at[0], at[1], at[2], radius],
color: [value[0], value[1], value[2], 1.0],
..Default::default()
},
);
let (pipe, field) = if dye {
(&self.pipes.splat_dye, &self.fields.dye)
} else {
(&self.pipes.splat_velocity, &self.fields.velocity)
};
encode(
cmd,
pipe,
Targets::One(field.write.id()),
false,
&u,
[field.read.id(); 3],
)?;
}
self.fields.velocity.swap();
self.fields.dye.swap();
}
commit(cmd);
self.occupancy_stale = true;
Ok(())
}
pub fn set_uniform_velocity(
&mut self,
device: &MetalDevice,
v: [f32; 3],
) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
let cmd = device.command_buffer();
let u = self.params(
self.sim,
Vol {
color: [v[0], v[1], v[2], 0.0],
..Default::default()
},
);
let f = &self.fields.velocity;
encode(
cmd,
&self.pipes.fill,
Targets::One(f.write.id()),
false,
&u,
[f.read.id(); 3],
)?;
commit(cmd);
self.fields.velocity.swap();
Ok(())
}
pub fn update(&mut self, device: &MetalDevice, dt: f32) -> Result<(), MetalError> {
let dt = dt * self.config.time_scale.max(0.0);
if !self.paused && dt > 0.0 {
self.step(device, dt)?;
}
Ok(())
}
pub fn step(&mut self, device: &MetalDevice, dt: f32) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
let cmd = device.command_buffer();
self.step_on(cmd, dt)?;
commit(cmd);
self.last_step = unsafe { Owned::retain(cmd) };
Ok(())
}
pub fn step_on(&mut self, cmd: Id, dt: f32) -> Result<(), MetalError> {
let c = self.config;
self.passes.set(0);
let sim = self.sim;
let axis = {
let a = c.buoyancy_axis;
let len = (a[0] * a[0] + a[1] * a[1] + a[2] * a[2]).sqrt();
if len > 1e-6 {
[a[0] / len, a[1] / len, a[2] / len]
} else {
[0.0; 3]
}
};
if c.buoyancy != 0.0 && axis != [0.0; 3] {
let u = self.params_mixed(
sim,
sim,
self.dye_atlas,
Vol {
texel: [0.0, 0.0, 0.0, dt],
params: [0.0, c.buoyancy, 0.0, 0.0],
color: [axis[0], axis[1], axis[2], 0.0],
..Default::default()
},
);
let f = &self.fields;
self.pass(
cmd,
&self.pipes.buoyancy,
f.velocity.write.id(),
&u,
[f.velocity.read.id(), f.dye.read.id()],
)?;
self.fields.velocity.swap();
}
if c.curl != 0.0 {
let u = self.params(sim, Vol::default());
let f = &self.fields;
self.pass(
cmd,
&self.pipes.curl,
f.curl.id(),
&u,
[f.velocity.read.id(); 2],
)?;
let u = self.params(
sim,
Vol {
texel: [0.0, 0.0, 0.0, dt],
params: [0.0, c.curl, 0.0, 0.0],
..Default::default()
},
);
self.pass(
cmd,
&self.pipes.vorticity,
f.velocity.write.id(),
&u,
[f.velocity.read.id(), f.curl.id()],
)?;
self.fields.velocity.swap();
}
let u = self.params(sim, Vol::default());
let f = &self.fields;
self.pass(
cmd,
&self.pipes.divergence,
f.divergence.id(),
&u,
[f.velocity.read.id(); 2],
)?;
match c.pressure_solver {
PressureSolver::Jacobi => self.jacobi(cmd, None, c.pressure_iterations, c.pressure)?,
PressureSolver::Multigrid => self.multigrid(cmd)?,
}
let u = self.params(
sim,
Vol {
params: [0.0, 0.0, c.gradient_scale, 0.0],
..Default::default()
},
);
let f = &self.fields;
self.pass(
cmd,
&self.pipes.gradient,
f.velocity.write.id(),
&u,
[f.pressure.read.id(), f.velocity.read.id()],
)?;
self.fields.velocity.swap();
let u = self.params(
sim,
Vol {
texel: [0.0, 0.0, 0.0, dt],
params: [c.velocity_dissipation, 0.0, 0.0, 0.0],
..Default::default()
},
);
let f = &self.fields;
self.pass(
cmd,
&self.pipes.advect_velocity,
f.velocity.write.id(),
&u,
[f.velocity.read.id(); 2],
)?;
self.fields.velocity.swap();
let u = self.params_mixed(
self.dye_atlas,
sim,
self.dye_atlas,
Vol {
texel: [0.0, 0.0, 0.0, dt],
params: [c.density_dissipation, 0.0, 0.0, 0.0],
..Default::default()
},
);
let f = &self.fields;
self.pass(
cmd,
&self.pipes.advect_dye,
f.dye.write.id(),
&u,
[f.velocity.read.id(), f.dye.read.id()],
)?;
self.fields.dye.swap();
self.occupancy_stale = true;
Ok(())
}
fn jacobi(
&mut self,
cmd: Id,
level: Option<usize>,
count: u32,
first_scale: f32,
) -> Result<(), MetalError> {
if count == 0 {
return Ok(());
}
let atlas = level.map_or(self.sim, |l| self.fields.mg[l].atlas);
let scaled = self.params(
atlas,
Vol {
params: [0.0, 0.0, first_scale, 0.0],
..Default::default()
},
);
let plain = self.params(
atlas,
Vol {
params: [0.0, 0.0, 1.0, 0.0],
..Default::default()
},
);
let (pressure, rhs) = match level {
None => (&self.fields.pressure, self.fields.divergence.id()),
Some(l) => (&self.fields.mg[l].pressure, self.fields.mg[l].rhs.id()),
};
let (a, b) = (pressure.read.id(), pressure.write.id());
for i in 0..count {
let even = i % 2 == 0;
let u = if i == 0 { &scaled } else { &plain };
let (src, dst) = if even { (a, b) } else { (b, a) };
encode(
cmd,
&self.pipes.pressure,
Targets::One(dst),
false,
u,
[src, rhs, src],
)?;
}
self.passes.set(self.passes.get() + count);
if count % 2 == 1 {
match level {
None => self.fields.pressure.swap(),
Some(l) => self.fields.mg[l].pressure.swap(),
}
}
Ok(())
}
fn multigrid(&mut self, cmd: Id) -> Result<(), MetalError> {
let c = self.config;
if self.fields.mg.is_empty() {
return self.jacobi(cmd, None, c.pressure_iterations, c.pressure);
}
let nu = c.multigrid_smooth.max(1);
let coarsest = self.fields.mg.last().map(|l| l.atlas.grid).unwrap_or(4);
let coarse_sweeps = (2 * coarsest).clamp(nu * 2, c.pressure_iterations.max(8));
let levels = self.fields.mg.len();
for cycle in 0..c.multigrid_cycles.max(1) {
let scale = if cycle == 0 { c.pressure } else { 1.0 };
self.jacobi(cmd, None, nu, scale)?;
for level in 0..levels {
self.residual(cmd, level)?;
self.restrict(cmd, level)?;
let sweeps = if level + 1 == levels {
coarse_sweeps
} else {
nu
};
self.jacobi(cmd, Some(level), sweeps, 0.0)?;
}
for level in (0..levels).rev() {
self.prolong(cmd, level)?;
if level == 0 {
self.jacobi(cmd, None, nu, 1.0)?;
} else {
self.jacobi(cmd, Some(level - 1), nu, 1.0)?;
}
}
}
Ok(())
}
fn residual(&mut self, cmd: Id, level: usize) -> Result<(), MetalError> {
let f = &self.fields;
let (atlas, pressure, rhs, target) = if level == 0 {
(
self.sim,
f.pressure.read.id(),
f.divergence.id(),
f.residual.id(),
)
} else {
let l = &f.mg[level - 1];
(l.atlas, l.pressure.read.id(), l.rhs.id(), l.residual.id())
};
let u = self.params(atlas, Vol::default());
self.pass(cmd, &self.pipes.residual, target, &u, [pressure, rhs])
}
fn restrict(&mut self, cmd: Id, level: usize) -> Result<(), MetalError> {
let f = &self.fields;
let (fine, residual) = if level == 0 {
(self.sim, f.residual.id())
} else {
let l = &f.mg[level - 1];
(l.atlas, l.residual.id())
};
let u = self.params_mixed(f.mg[level].atlas, fine, fine, Vol::default());
self.pass(
cmd,
&self.pipes.restrict,
f.mg[level].rhs.id(),
&u,
[residual; 2],
)
}
fn prolong(&mut self, cmd: Id, level: usize) -> Result<(), MetalError> {
let f = &self.fields;
let coarse = f.mg[level].atlas;
let (fine, read, write) = if level == 0 {
(self.sim, f.pressure.read.id(), f.pressure.write.id())
} else {
let l = &f.mg[level - 1];
(l.atlas, l.pressure.read.id(), l.pressure.write.id())
};
let u = self.params_mixed(fine, coarse, fine, Vol::default());
self.pass(
cmd,
&self.pipes.prolong,
write,
&u,
[f.mg[level].pressure.read.id(), read],
)?;
if level == 0 {
self.fields.pressure.swap();
} else {
self.fields.mg[level - 1].pressure.swap();
}
Ok(())
}
fn occupancy(&mut self, cmd: Id) -> Result<(), MetalError> {
let mut source = (self.dye_atlas, self.fields.dye.read.id());
for level in 0..2 {
let (atlas, target) = (
self.fields.occupancy[level].0,
self.fields.occupancy[level].1.id(),
);
let u = self.params_mixed(atlas, source.0, source.0, Vol::default());
encode(
cmd,
&self.pipes.maxdown,
Targets::One(target),
false,
&u,
[source.1; 3],
)?;
source = (atlas, target);
}
Ok(())
}
pub fn render(
&mut self,
device: &MetalDevice,
camera: &dyn Camera,
target: Id,
format: NSUInteger,
size: (u32, u32),
) -> Result<(), MetalError> {
let _pool = AutoreleasePool::new();
let cmd = device.command_buffer();
self.render_on(device, cmd, camera, target, format, size)?;
commit(cmd);
Ok(())
}
pub fn render_on(
&mut self,
device: &MetalDevice,
cmd: Id,
camera: &dyn Camera,
target: Id,
format: NSUInteger,
size: (u32, u32),
) -> Result<(), MetalError> {
let c = self.config;
let accumulating = self.prepare_accum(device, size)?;
let view_proj = camera.projection_matrix().multiply(&camera.view_matrix());
let inv = view_proj.invert();
self.view_proj = view_proj.elements;
self.view_proj_inverse = inv.elements;
let pos = camera.position();
let skip_floor = if c.empty_space_skip { 0.0008 } else { 0.0 };
let u = self.params_mixed(
self.dye_atlas,
self.dye_atlas,
self.fields.occupancy[1].0,
Vol {
params: [skip_floor, self.accum_frame as f32, 0.0, 0.0],
bounds_min: [c.bounds_min[0], c.bounds_min[1], c.bounds_min[2], 0.0],
bounds_max: [c.bounds_max[0], c.bounds_max[1], c.bounds_max[2], 0.0],
march: [
c.march_steps.max(1) as f32,
c.absorption,
c.emission,
c.exposure,
],
background: [
c.background[0],
c.background[1],
c.background[2],
if c.transparent { 1.0 } else { 0.0 },
],
cam_pos: [pos.x, pos.y, pos.z, 1.0],
inv_view_proj: inv.elements,
prev_view_proj: self.accum_from.unwrap_or(view_proj.elements),
..Default::default()
},
);
if c.empty_space_skip && self.occupancy_stale {
self.occupancy(cmd)?;
self.occupancy_stale = false;
}
let textures = [
self.fields.dye.read.id(),
self.fields.occupancy[1].1.id(),
self.fields.dye.read.id(),
];
if accumulating {
self.accumulated_march(device, cmd, target, format, &u, textures)?;
self.accum_frame += 1;
self.accum_from = Some(view_proj.elements);
} else {
let pipe = self.output(device, format, Output::March)?;
encode(cmd, &pipe, Targets::One(target), false, &u, textures)?;
}
if c.show_fps {
self.read_out(device, cmd, target, format)?;
}
self.rate.tick();
Ok(())
}
fn prepare_accum(
&mut self,
device: &MetalDevice,
size: (u32, u32),
) -> Result<bool, MetalError> {
if self.config.temporal_samples <= 1 {
self.accum = None;
self.accum_from = None;
return Ok(false);
}
let (w, h) = (size.0.max(1), size.1.max(1));
if self.accum.as_ref().is_none_or(|a| a.size != (w, h)) {
let make = |f| texture(device, w, h, f);
let history = Pair {
read: make(VEC)?,
write: make(VEC)?,
};
let cmd = device.command_buffer();
clear_to_zero(cmd, history.read.id())?;
clear_to_zero(cmd, history.write.id())?;
commit(cmd);
self.accum = Some(Accum {
size: (w, h),
current: make(VEC)?,
depth: make(SCALAR)?,
history,
});
self.accum_from = None;
self.accum_frame = 0;
}
Ok(true)
}
fn accumulated_march(
&mut self,
device: &MetalDevice,
cmd: Id,
target: Id,
format: NSUInteger,
u: &Vol,
textures: [Id; 3],
) -> Result<(), MetalError> {
if self.accum_march.is_none() {
let fs = function(&self.library, &self.names, "fs_raymarch_depth")?;
self.accum_march = Some(pipeline(device, &self.vertex, &fs, &[VEC, SCALAR], false)?);
}
let weight = if self.accum_frame == 0 {
1.0
} else {
1.0 / self.config.temporal_samples.max(2) as f32
};
let resolve = self.output(device, format, Output::Resolve)?;
let r = Vol {
params: [0.0, 0.0, weight, self.config.temporal_clip],
inv_view_proj: self.view_proj_inverse,
prev_view_proj: self.accum_from.unwrap_or(self.view_proj),
..self.params(self.dye_atlas, Vol::default())
};
let a = self.accum.as_mut().expect("prepare_accum made one");
let march = self.accum_march.as_ref().expect("just built");
encode(
cmd,
march,
Targets::Many(&[a.current.id(), a.depth.id()]),
false,
u,
textures,
)?;
encode(
cmd,
&resolve,
Targets::Many(&[a.history.write.id(), target]),
false,
&r,
[a.current.id(), a.history.read.id(), a.depth.id()],
)?;
a.history.swap();
Ok(())
}
fn read_out(
&mut self,
device: &MetalDevice,
cmd: Id,
target: Id,
format: NSUInteger,
) -> Result<(), MetalError> {
let row = device.new_buffer(&self.rate.frames().row())?;
blit_row_to_texture(cmd, &row, &self.history, Frames::LEN as u32)?;
let u = self.params(
self.dye_atlas,
Vol {
params: [
self.rate.fps(),
self.rate.scale_ms(),
self.rate.target_ms(),
0.0,
],
..Default::default()
},
);
let pipe = self.output(device, format, Output::Overlay)?;
encode(
cmd,
&pipe,
Targets::One(target),
true,
&u,
[self.history.id(); 3],
)
}
fn output(
&mut self,
device: &MetalDevice,
format: NSUInteger,
which: Output,
) -> Result<Owned, MetalError> {
let cache = match which {
Output::March => &mut self.march,
Output::Resolve => &mut self.resolve,
Output::Overlay => &mut self.overlay,
};
if let Some((_, p)) = cache.iter().find(|(f, _)| *f == format) {
return Ok(unsafe { Owned::retain(p.id()) }.expect("a live pipeline"));
}
let (fs, formats, blend): (&str, Vec<NSUInteger>, bool) = match which {
Output::March => ("fs_raymarch", vec![format], false),
Output::Resolve => ("fs_resolve3", vec![VEC, format], false),
Output::Overlay => ("fs_overlay3", vec![format], true),
};
let p = pipeline(
device,
&self.vertex,
&function(&self.library, &self.names, fs)?,
&formats,
blend,
)?;
let out = unsafe { Owned::retain(p.id()) }.expect("a live pipeline");
cache.push((format, p));
Ok(out)
}
#[cfg(metal_backend)]
pub fn render_over(
&mut self,
renderer: &mut super::MetalRenderer,
camera: &dyn Camera,
pass: &super::PassAttachments,
) -> Result<(), MetalError> {
let (w, h) = pass.size();
let (w, h) = (w.max(1), h.max(1));
if !matches!(&self.over, Some((_, ow, oh)) if (*ow, *oh) == (w, h)) {
self.over = Some((texture(renderer.device(), w, h, pixel_format::RGBA16_FLOAT)?, w, h));
}
let target = self.over.as_ref().map(|(t, _, _)| t.id()).expect("made above");
let device = renderer.device().clone();
self.render(&device, camera, target, pixel_format::RGBA16_FLOAT, (w, h))?;
renderer.blend_texture(target, pass)
}
#[cfg(metal_backend)]
pub fn capture_rgba(
&mut self,
device: &MetalDevice,
camera: &dyn Camera,
width: u32,
height: u32,
) -> Result<Vec<u8>, MetalError> {
use super::target::{blit_texture_to_buffer_on_cmd, finish_texture_readback_into};
let _pool = AutoreleasePool::new();
let (w, h) = (width.max(1), height.max(1));
let target = texture(device, w, h, pixel_format::RGBA8_UNORM)?;
self.render(
device,
camera,
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 = device.command_buffer();
blit_texture_to_buffer_on_cmd(cmd, target.id(), w, h, &staging, padded)?;
commit(cmd);
let mut out = Vec::new();
finish_texture_readback_into(cmd, &staging, w, h, pixel_format::RGBA8_UNORM, &mut out)?;
Ok(out)
}
fn params(&self, atlas: Atlas, rest: Vol) -> Vol {
self.params_mixed(atlas, atlas, atlas, rest)
}
fn params_mixed(&self, out: Atlas, a: Atlas, b: Atlas, rest: Vol) -> Vol {
Vol {
out_grid: out.into(),
a_grid: a.into(),
b_grid: b.into(),
..rest
}
}
fn pass(
&self,
cmd: Id,
pipe: &Owned,
target: Id,
u: &Vol,
textures: [Id; 2],
) -> Result<(), MetalError> {
self.passes.set(self.passes.get() + 1);
encode(
cmd,
pipe,
Targets::One(target),
false,
u,
[textures[0], textures[1], textures[0]],
)
}
}
#[derive(Clone, Copy)]
enum Output {
March,
Resolve,
Overlay,
}
fn max_texture_side(device: &MetalDevice) -> u32 {
let _ = device;
16384
}
fn function(
library: &Owned,
names: &HashMap<String, String>,
wgsl: &str,
) -> Result<Owned, MetalError> {
let name = names.get(wgsl).map(String::as_str).unwrap_or(wgsl);
let _pool = AutoreleasePool::new();
unsafe {
let f: Id = msg1(library.id(), sel!("newFunctionWithName:"), nsstring(name));
Owned::from_retained(f).ok_or_else(|| MetalError::MissingFunction(name.into()))
}
}
fn pipeline(
device: &MetalDevice,
vs: &Owned,
fs: &Owned,
formats: &[NSUInteger],
blend: bool,
) -> Result<Owned, MetalError> {
let _pool = AutoreleasePool::new();
unsafe {
let desc = Owned::from_retained(alloc_init(class!("MTLRenderPipelineDescriptor")))
.ok_or_else(|| MetalError::Allocation("MTLRenderPipelineDescriptor".into()))?;
let _: () = msg1(desc.id(), sel!("setVertexFunction:"), vs.id());
let _: () = msg1(desc.id(), sel!("setFragmentFunction:"), fs.id());
let attachments: Id = msg0(desc.id(), sel!("colorAttachments"));
for (i, format) in formats.iter().enumerate() {
let color: Id = msg1(attachments, sel!("objectAtIndexedSubscript:"), i);
let _: () = msg1(color, sel!("setPixelFormat:"), *format);
if blend && i == 0 {
let _: () = msg1(color, sel!("setBlendingEnabled:"), YES);
let _: () = msg1(color, sel!("setRgbBlendOperation:"), blend_op::ADD);
let _: () = msg1(color, sel!("setAlphaBlendOperation:"), blend_op::ADD);
let _: () = msg1(
color,
sel!("setSourceRGBBlendFactor:"),
blend_factor::SOURCE_ALPHA,
);
let _: () = msg1(
color,
sel!("setDestinationRGBBlendFactor:"),
blend_factor::ONE_MINUS_SOURCE_ALPHA,
);
let _: () = msg1(color, sel!("setSourceAlphaBlendFactor:"), blend_factor::ONE);
let _: () = msg1(
color,
sel!("setDestinationAlphaBlendFactor:"),
blend_factor::ONE_MINUS_SOURCE_ALPHA,
);
}
}
let mut err: Id = NIL;
let state: Id = msg2(
device.device_id(),
sel!("newRenderPipelineStateWithDescriptor:error:"),
desc.id(),
&mut err as *mut Id,
);
Owned::from_retained(state).ok_or_else(|| MetalError::PipelineCreation(error_message(err)))
}
}
fn encode(
cmd: Id,
pipe: &Owned,
targets: Targets<'_>,
load: bool,
u: &Vol,
textures: [Id; 3],
) -> Result<(), MetalError> {
let one;
let targets: &[Id] = match targets {
Targets::One(t) => {
one = [t];
&one
}
Targets::Many(ts) => ts,
};
let _pool = AutoreleasePool::new();
unsafe {
let desc: Id = msg0(
class!("MTLRenderPassDescriptor"),
sel!("renderPassDescriptor"),
);
let attachments: Id = msg0(desc, sel!("colorAttachments"));
for (i, t) in targets.iter().enumerate() {
let color: Id = msg1(attachments, sel!("objectAtIndexedSubscript:"), i);
let _: () = msg1(color, sel!("setTexture:"), *t);
let action = if load {
load_action::LOAD
} else {
load_action::CLEAR
};
let _: () = msg1(color, sel!("setLoadAction:"), action);
let _: () = msg1(color, sel!("setStoreAction:"), store_action::STORE);
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(
"fluid3d render encoder failed".into(),
));
}
let _: () = msg1(enc, sel!("setRenderPipelineState:"), pipe.id());
let bytes = bytemuck::bytes_of(u);
let _: () = msg3(
enc,
sel!("setFragmentBytes:length:atIndex:"),
bytes.as_ptr(),
bytes.len(),
0usize,
);
for (i, t) in textures.iter().enumerate() {
let _: () = msg2(enc, sel!("setFragmentTexture:atIndex:"), *t, i);
}
let _: () = msg3(
enc,
sel!("drawPrimitives:vertexStart:vertexCount:"),
primitive::TRIANGLE,
0usize,
3usize,
);
let _: () = msg0(enc, sel!("endEncoding"));
}
Ok(())
}
#[cfg(all(test, metal_core))]
mod tests {
use super::*;
use crate::{PerspectiveCamera, Vector3};
fn device() -> Option<MetalDevice> {
MetalDevice::new().ok()
}
fn camera() -> PerspectiveCamera {
let mut c = PerspectiveCamera::new(45.0, 1.0, 0.05, 20.0);
c.position = Vector3::new(0.6, 0.3, 1.8);
c.look_at(Vector3::ZERO);
c
}
fn small() -> FluidConfig3d {
FluidConfig3d {
resolution: 32,
dye_resolution: 48,
march_steps: 48,
buoyancy: 30.0,
..FluidConfig3d::default()
}
}
#[test]
fn the_volume_translates_to_msl() {
let (msl, names) = fluid3d_shader_source().expect("translates");
for entry in [
"vs_main",
"fs_fill3",
"fs_buoyancy3",
"fs_splat3",
"fs_advect3",
"fs_advect3_self",
"fs_divergence3",
"fs_curl3",
"fs_vorticity3",
"fs_pressure3",
"fs_gradient3",
"fs_residual3",
"fs_restrict3",
"fs_prolong3",
"fs_maxdown3",
"fs_resolve3",
"fs_overlay3",
"fs_raymarch",
"fs_raymarch_depth",
] {
let name = names.get(entry).unwrap_or_else(|| panic!("no `{entry}`"));
assert!(msl.contains(name.as_str()), "`{name}` is not in the MSL");
}
}
#[cfg(feature = "render")]
#[test]
fn the_vertex_stage_is_the_renderers() {
assert_eq!(VS, crate::renderer::fullscreen::VS);
}
#[test]
fn the_budget_buys_a_volume_that_fits() {
let (solver, dye) = MetalFluid3d::within_memory(64 << 20, 2);
assert!(solver >= 32 && dye == solver * 2, "{solver}/{dye}");
assert!(MetalFluid3d::memory_for(solver, dye) <= 64 << 20);
assert!(MetalFluid3d::memory_for(solver + 8, dye + 16) > 64 << 20);
}
#[test]
fn a_volume_steps_and_draws_every_way() {
let Some(device) = device() else { return };
let cam = camera();
for (solver, samples, fps) in [
(PressureSolver::Multigrid, 1, false),
(PressureSolver::Jacobi, 1, true),
(PressureSolver::Multigrid, 4, true),
] {
let mut fluid = MetalFluid3d::new(
&device,
FluidConfig3d {
pressure_solver: solver,
temporal_samples: samples,
show_fps: fps,
..small()
},
)
.unwrap();
fluid.multiple_splats(&device, 4).unwrap();
fluid
.impulse_at_screen(
&device,
&cam,
[0.5, 0.5],
[0.05, -0.02],
6.0,
[1.0, 0.4, 0.2],
)
.unwrap();
for _ in 0..6 {
fluid.update(&device, 1.0 / 60.0).unwrap();
}
assert!(
fluid.passes_per_step() > 10,
"a step of {} passes",
fluid.passes_per_step()
);
#[cfg(metal_backend)]
{
let rgba = fluid.capture_rgba(&device, &cam, 96, 96).unwrap();
let lit = rgba
.chunks(4)
.filter(|p| p[0].max(p[1]).max(p[2]) > 40)
.count();
assert!(
lit > 50,
"{solver:?}, {samples} samples: only {lit} pixels lit"
);
}
}
}
#[cfg(all(metal_backend, feature = "fluid"))]
#[test]
fn metal_fluid3d_matches_wgpu() {
use crate::fluid::FluidSim3d;
let Some(device) = device() else { return };
let Some(gpu) = crate::gpu::testing::context("fluid3d parity") else {
return;
};
let cam = camera();
for (solver, samples) in [
(PressureSolver::Multigrid, 1),
(PressureSolver::Jacobi, 1),
(PressureSolver::Multigrid, 3),
] {
let config = FluidConfig3d {
pressure_solver: solver,
temporal_samples: samples,
..small()
};
let mut wgpu_sim =
FluidSim3d::new(gpu.device.clone(), gpu.queue.clone(), config).unwrap();
let mut metal = MetalFluid3d::new(&device, config).unwrap();
assert_eq!(metal.grids(), wgpu_sim.grids());
assert_eq!(
metal.memory_bytes(),
wgpu_sim.memory_bytes(),
"the two allocate differently"
);
wgpu_sim.multiple_splats(5);
metal.multiple_splats(&device, 5).unwrap();
wgpu_sim.impulse_at_screen(&cam, [0.45, 0.55], [0.04, 0.0], 6.0, [0.2, 0.6, 1.0]);
metal
.impulse_at_screen(
&device,
&cam,
[0.45, 0.55],
[0.04, 0.0],
6.0,
[0.2, 0.6, 1.0],
)
.unwrap();
let (mut a, mut b) = (Vec::new(), Vec::new());
for _ in 0..10 {
wgpu_sim.step(1.0 / 60.0);
metal.step(&device, 1.0 / 60.0).unwrap();
a = wgpu_sim.capture_rgba(&cam, 128, 128);
b = metal.capture_rgba(&device, &cam, 128, 128).unwrap();
}
let lit = a
.chunks(4)
.filter(|p| p[0].max(p[1]).max(p[2]) > 40)
.count();
assert!(lit > 100, "{solver:?}: wgpu drew almost nothing ({lit})");
let mean = a
.iter()
.zip(&b)
.map(|(x, y)| (*x as i32 - *y as i32).abs() as f64)
.sum::<f64>()
/ a.len() as f64;
let worst = a
.iter()
.zip(&b)
.map(|(x, y)| (*x as i32 - *y as i32).abs())
.max()
.unwrap_or(0);
eprintln!(" {solver:?}, {samples} samples: mean |diff| {mean:.3}/255, worst {worst}");
assert!(worst <= 1, "{solver:?}, {samples} samples: the backends drew different volumes (mean {mean:.3}, worst {worst})");
}
}
}