use isomesh::Sdf;
use crate::{Error, GridParams, Result};
#[derive(Debug)]
pub struct FieldBuffer {
buffer: wgpu::Buffer,
params: GridParams,
}
impl FieldBuffer {
#[must_use]
pub fn new(device: &wgpu::Device, params: GridParams) -> Self {
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh field samples"),
size: params.field_buffer_size(),
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_DST
| wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
Self { buffer, params }
}
pub fn uploaded(
device: &wgpu::Device,
queue: &wgpu::Queue,
params: GridParams,
samples: &[f32],
) -> Result<Self> {
let expected = params.sample_count();
let got = samples.len() as u64;
if got != expected {
return Err(Error::SampleCountMismatch { expected, got });
}
let mut bytes = Vec::with_capacity(samples.len() * 4);
for sample in samples {
bytes.extend_from_slice(&sample.to_le_bytes());
}
Ok(Self::from_bytes(device, queue, params, &bytes))
}
fn from_bytes(
device: &wgpu::Device,
queue: &wgpu::Queue,
params: GridParams,
bytes: &[u8],
) -> Self {
let field = Self::new(device, params);
queue.write_buffer(&field.buffer, 0, bytes);
field
}
pub fn sampled<F>(
device: &wgpu::Device,
queue: &wgpu::Queue,
params: GridParams,
field: &F,
) -> Result<Self>
where
F: Sdf<Scalar = f32>,
{
let [sx, sy, sz] = params.samples();
let mut bytes = Vec::with_capacity(params.sample_count() as usize * 4);
for z in 0..sz {
for y in 0..sy {
for x in 0..sx {
let sample = field.sample(params.sample_position([x, y, z]));
bytes.extend_from_slice(&sample.to_le_bytes());
}
}
}
Ok(Self::from_bytes(device, queue, params, &bytes))
}
#[must_use]
pub const fn buffer(&self) -> &wgpu::Buffer {
&self.buffer
}
#[must_use]
pub const fn params(&self) -> GridParams {
self.params
}
}
pub fn read_buffer(
device: &wgpu::Device,
queue: &wgpu::Queue,
source: &wgpu::Buffer,
bytes: u64,
) -> Result<Vec<f32>> {
let raw = read_bytes(device, queue, source, bytes)?;
Ok(raw
.as_chunks::<4>()
.0
.iter()
.map(|w| f32::from_le_bytes([w[0], w[1], w[2], w[3]]))
.collect())
}
pub fn read_buffer_u32(
device: &wgpu::Device,
queue: &wgpu::Queue,
source: &wgpu::Buffer,
bytes: u64,
) -> Result<Vec<u32>> {
let raw = read_bytes(device, queue, source, bytes)?;
Ok(raw
.as_chunks::<4>()
.0
.iter()
.map(|w| u32::from_le_bytes([w[0], w[1], w[2], w[3]]))
.collect())
}
pub fn read_bytes(
device: &wgpu::Device,
queue: &wgpu::Queue,
source: &wgpu::Buffer,
bytes: u64,
) -> Result<Vec<u8>> {
let mut out = read_bytes_many(device, queue, &[(source, bytes)])?;
match out.pop() {
Some(only) => Ok(only),
None => Err(Error::DeviceLost),
}
}
pub fn read_bytes_many(
device: &wgpu::Device,
queue: &wgpu::Queue,
requests: &[(&wgpu::Buffer, u64)],
) -> Result<Vec<Vec<u8>>> {
for (_, bytes) in requests {
if !bytes.is_multiple_of(4) {
return Err(Error::UnalignedReadback {
bytes: *bytes,
stride: 4,
});
}
}
if requests.is_empty() {
return Ok(Vec::new());
}
let total: u64 = requests.iter().map(|(_, bytes)| *bytes).sum();
let staging = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh readback"),
size: total,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("isomesh readback copy"),
});
let mut at = 0u64;
for (source, bytes) in requests {
encoder.copy_buffer_to_buffer(source, 0, &staging, at, *bytes);
at += *bytes;
}
queue.submit(Some(encoder.finish()));
let (sender, receiver) = std::sync::mpsc::channel();
staging
.slice(..)
.map_async(wgpu::MapMode::Read, move |result| {
let _ = sender.send(result);
});
device
.poll(wgpu::PollType::Wait {
submission_index: None,
timeout: None,
})
.map_err(|_| Error::DeviceLost)?;
match receiver.recv() {
Ok(Ok(())) => {}
Ok(Err(_)) => return Err(Error::MapFailed),
Err(_) => return Err(Error::DeviceLost),
}
let view = staging
.slice(..)
.get_mapped_range()
.map_err(|_| Error::MapFailed)?;
let mut out = Vec::with_capacity(requests.len());
let mut at = 0usize;
for (_, bytes) in requests {
let len = usize::try_from(*bytes).map_err(|_| Error::DeviceLost)?;
let end = at.checked_add(len).ok_or(Error::DeviceLost)?;
let slice = view.get(at..end).ok_or(Error::DeviceLost)?;
out.push(slice.to_vec());
at = end;
}
drop(view);
staging.unmap();
Ok(out)
}
#[derive(Debug)]
pub struct Readback {
staging: Option<wgpu::Buffer>,
state: std::sync::Arc<std::sync::atomic::AtomicU8>,
spans: Vec<usize>,
}
pub fn read_bytes_many_deferred(
device: &wgpu::Device,
queue: &wgpu::Queue,
requests: &[(&wgpu::Buffer, u64)],
) -> Result<Readback> {
for (_, bytes) in requests {
if !bytes.is_multiple_of(4) {
return Err(Error::UnalignedReadback {
bytes: *bytes,
stride: 4,
});
}
}
let state = std::sync::Arc::new(std::sync::atomic::AtomicU8::new(0));
if requests.is_empty() {
state.store(1, std::sync::atomic::Ordering::Release);
return Ok(Readback {
staging: None,
state,
spans: Vec::new(),
});
}
let mut spans = Vec::with_capacity(requests.len());
for (_, bytes) in requests {
spans.push(usize::try_from(*bytes).map_err(|_| Error::DeviceLost)?);
}
let total: u64 = requests.iter().map(|(_, bytes)| *bytes).sum();
let staging = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh deferred readback"),
size: total,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("isomesh deferred readback copy"),
});
let mut at = 0u64;
for (source, bytes) in requests {
encoder.copy_buffer_to_buffer(source, 0, &staging, at, *bytes);
at += *bytes;
}
queue.submit(Some(encoder.finish()));
let signal = std::sync::Arc::clone(&state);
staging
.slice(..)
.map_async(wgpu::MapMode::Read, move |result| {
let code = if result.is_ok() { 1 } else { 2 };
signal.store(code, std::sync::atomic::Ordering::Release);
});
Ok(Readback {
staging: Some(staging),
state,
spans,
})
}
impl Readback {
#[must_use]
pub fn ready(&self, device: &wgpu::Device) -> bool {
let _ = device.poll(wgpu::PollType::Poll);
self.state.load(std::sync::atomic::Ordering::Acquire) != 0
}
pub fn take(self) -> Result<Vec<Vec<u8>>> {
match self.state.load(std::sync::atomic::Ordering::Acquire) {
1 => {}
2 => return Err(Error::MapFailed),
_ => return Err(Error::DeviceLost),
}
let Some(staging) = self.staging else {
return Ok(Vec::new());
};
let view = staging
.slice(..)
.get_mapped_range()
.map_err(|_| Error::MapFailed)?;
let mut out = Vec::with_capacity(self.spans.len());
let mut at = 0usize;
for len in &self.spans {
let end = at.checked_add(*len).ok_or(Error::DeviceLost)?;
let slice = view.get(at..end).ok_or(Error::DeviceLost)?;
out.push(slice.to_vec());
at = end;
}
drop(view);
staging.unmap();
Ok(out)
}
}
#[derive(Debug)]
pub struct DeferredGeometry<K> {
slots: Vec<Option<(K, Readback)>>,
}
const _: fn() = || {
fn assert<T: Send + Sync>() {}
assert::<DeferredGeometry<u32>>();
};
impl<K> DeferredGeometry<K> {
pub fn new(capacity: usize) -> Result<Self> {
if capacity == 0 {
return Err(Error::DeferredQueueFull { capacity });
}
let mut slots = Vec::with_capacity(capacity);
slots.resize_with(capacity, || None);
Ok(Self { slots })
}
#[must_use]
pub fn has_room(&self) -> bool {
self.slots.iter().any(Option::is_none)
}
pub fn submit(&mut self, key: K, readback: Readback) -> Result<()> {
let capacity = self.slots.len();
let Some(slot) = self.slots.iter_mut().find(|slot| slot.is_none()) else {
return Err(Error::DeferredQueueFull { capacity });
};
*slot = Some((key, readback));
Ok(())
}
pub fn drain_ready(&mut self, device: &wgpu::Device) -> Result<Vec<(K, Vec<Vec<u8>>)>> {
let mut out = Vec::new();
for slot in &mut self.slots {
let ready = slot
.as_ref()
.is_some_and(|(_, readback)| readback.ready(device));
if !ready {
continue;
}
let (key, readback) = slot.take().expect("checked above");
out.push((key, readback.take()?));
}
Ok(out)
}
#[must_use]
pub fn in_flight(&self) -> usize {
self.slots.iter().filter(|slot| slot.is_some()).count()
}
#[must_use]
pub fn capacity(&self) -> usize {
self.slots.len()
}
}
#[cfg(test)]
mod tests;