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
.chunks_exact(4)
.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
.chunks_exact(4)
.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>> {
if bytes % 4 != 0 {
return Err(Error::UnalignedReadback { bytes, stride: 4 });
}
let staging = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh readback"),
size: bytes,
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"),
});
encoder.copy_buffer_to_buffer(source, 0, &staging, 0, 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 out = staging.slice(..).get_mapped_range().to_vec();
staging.unmap();
Ok(out)
}
#[cfg(test)]
mod tests;