use glam::DVec3;
use pointblitz_io::chunk::{
self, ChunkError, ChunkHeader, FLAG_FIRST_PASS_COMPLETE, FLAG_LAST_IN_GENERATION,
};
use wgpu::util::DeviceExt;
pub struct GpuChunk {
pub buffer: wgpu::Buffer,
pub points: u32,
pub origin: DVec3,
pub header: ChunkHeader,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Inserted {
Appended,
Pending,
Swapped { from: Option<u32>, to: u32 },
Stale,
}
#[derive(Default)]
pub struct Scene {
current: Option<u32>,
shown: Vec<GpuChunk>,
pending: Option<(u32, Vec<GpuChunk>)>,
}
impl Scene {
pub fn new() -> Self {
Self::default()
}
pub fn generation(&self) -> Option<u32> {
self.current
}
pub fn visible_chunks(&self) -> &[GpuChunk] {
&self.shown
}
pub fn points(&self) -> u64 {
self.shown.iter().map(|c| u64::from(c.points)).sum()
}
pub fn gpu_bytes(&self) -> u64 {
let pending = self.pending.iter().flat_map(|(_, v)| v);
self.shown
.iter()
.chain(pending)
.map(|c| c.buffer.size())
.sum()
}
pub fn insert(&mut self, device: &wgpu::Device, bytes: &[u8]) -> Result<Inserted, ChunkError> {
let header = chunk::decode_header(bytes)?;
let generation = header.generation;
let last = header.flags & (FLAG_LAST_IN_GENERATION | FLAG_FIRST_PASS_COMPLETE) != 0;
if self.current.is_some_and(|cur| generation < cur) {
return Ok(Inserted::Stale);
}
let gpu = upload(device, bytes, header);
match self.current {
None => {
self.current = Some(generation);
self.shown.push(gpu);
Ok(Inserted::Appended)
}
Some(cur) if cur == generation => {
self.shown.push(gpu);
Ok(Inserted::Appended)
}
Some(cur) => {
match &mut self.pending {
Some((g, v)) if *g == generation => v.push(gpu),
Some((g, _)) if *g > generation => return Ok(Inserted::Stale),
_ => self.pending = Some((generation, vec![gpu])),
}
if last {
let (g, v) = self.pending.take().expect("pending set above");
self.shown = v; self.current = Some(g);
Ok(Inserted::Swapped {
from: Some(cur),
to: g,
})
} else {
Ok(Inserted::Pending)
}
}
}
}
}
fn upload(device: &wgpu::Device, bytes: &[u8], header: ChunkHeader) -> GpuChunk {
let body = chunk::vertex_bytes(bytes);
let contents: &[u8] = if body.is_empty() { &[0u8; 12] } else { body };
let buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("chunk"),
contents,
usage: wgpu::BufferUsages::VERTEX,
});
GpuChunk {
buffer,
points: header.point_count,
origin: DVec3::from(header.origin),
header,
}
}