#[cfg(test)]
mod tests;
use crate::{Composer, Error, FieldBuffer, GridParams, Result, read_buffer};
const WORKGROUP: u32 = 64;
const SEED_STRIDE: u64 = 16;
#[derive(Debug)]
pub struct JumpFlood {
seed: wgpu::ComputePipeline,
flood: wgpu::ComputePipeline,
resolve: wgpu::ComputePipeline,
layout: wgpu::BindGroupLayout,
}
impl JumpFlood {
pub fn new(device: &wgpu::Device) -> Result<Self> {
let source = Composer::with_builtins().compose("jump_flood", &[])?;
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("isomesh jump flood"),
source: wgpu::ShaderSource::Wgsl(source.into()),
});
let entry = |binding: u32, ty: wgpu::BufferBindingType| wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
};
let read = wgpu::BufferBindingType::Storage { read_only: true };
let write = wgpu::BufferBindingType::Storage { read_only: false };
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("isomesh jump flood bindings"),
entries: &[
entry(0, wgpu::BufferBindingType::Uniform),
entry(1, wgpu::BufferBindingType::Uniform),
entry(2, read),
entry(3, write),
entry(4, write),
entry(5, write),
],
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("isomesh jump flood layout"),
bind_group_layouts: &[Some(&layout)],
immediate_size: 0,
});
let compile = |entry_point: &str| {
device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some(entry_point),
layout: Some(&pipeline_layout),
module: &module,
entry_point: Some(entry_point),
compilation_options: wgpu::PipelineCompilationOptions::default(),
cache: None,
})
};
Ok(Self {
seed: compile("seed"),
flood: compile("flood"),
resolve: compile("resolve"),
layout,
})
}
#[must_use]
pub fn strides(params: GridParams) -> Vec<u32> {
let s = params.samples();
let longest = s[0].max(s[1]).max(s[2]);
let mut out = Vec::new();
let mut k = longest / 2;
while k >= 1 {
out.push(k);
k /= 2;
}
out
}
pub fn build(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
field: &FieldBuffer,
) -> Result<Vec<f32>> {
let params = field.params();
let count = params.sample_count();
if count == 0 {
return Err(Error::DegenerateGrid {
samples: params.samples(),
});
}
let grid_uniform = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh jump flood grid"),
size: GridParams::UNIFORM_SIZE,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
queue.write_buffer(&grid_uniform, 0, ¶ms.to_std140());
let strides = Self::strides(params);
let mut step_uniforms = Vec::with_capacity(strides.len() + 1);
for &k in core::iter::once(&0u32).chain(strides.iter()) {
let buf = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh jump flood step"),
size: 16,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let mut bytes = [0u8; 16];
bytes[..4].copy_from_slice(&k.to_le_bytes());
queue.write_buffer(&buf, 0, &bytes);
step_uniforms.push(buf);
}
let seeds = |label: &str| {
device.create_buffer(&wgpu::BufferDescriptor {
label: Some(label),
size: count * SEED_STRIDE,
usage: wgpu::BufferUsages::STORAGE,
mapped_at_creation: false,
})
};
let ping = seeds("isomesh jump flood seeds A");
let pong = seeds("isomesh jump flood seeds B");
let out = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh jump flood distance"),
size: count * 4,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let bind = |step: &wgpu::Buffer, src: &wgpu::Buffer, dst: &wgpu::Buffer| {
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("isomesh jump flood bindings"),
layout: &self.layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: grid_uniform.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: step.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 2,
resource: field.buffer().as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 3,
resource: src.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 4,
resource: dst.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 5,
resource: out.as_entire_binding(),
},
],
})
};
let groups = count.div_ceil(u64::from(WORKGROUP)) as u32;
let mut encoder =
device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
let mut live_is_pong = true;
{
let group = bind(&step_uniforms[0], &ping, &pong);
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("isomesh jump flood seed"),
timestamp_writes: None,
});
pass.set_pipeline(&self.seed);
pass.set_bind_group(0, &group, &[]);
pass.dispatch_workgroups(groups, 1, 1);
}
for (i, _) in strides.iter().enumerate() {
let (src, dst) = if live_is_pong {
(&pong, &ping)
} else {
(&ping, &pong)
};
let group = bind(&step_uniforms[i + 1], src, dst);
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("isomesh jump flood"),
timestamp_writes: None,
});
pass.set_pipeline(&self.flood);
pass.set_bind_group(0, &group, &[]);
pass.dispatch_workgroups(groups, 1, 1);
live_is_pong = !live_is_pong;
}
{
let live = if live_is_pong { &pong } else { &ping };
let other = if live_is_pong { &ping } else { &pong };
let group = bind(&step_uniforms[0], live, other);
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("isomesh jump flood resolve"),
timestamp_writes: None,
});
pass.set_pipeline(&self.resolve);
pass.set_bind_group(0, &group, &[]);
pass.dispatch_workgroups(groups, 1, 1);
}
queue.submit(Some(encoder.finish()));
read_buffer(device, queue, &out, count * 4)
}
}