126 lines
4.1 KiB
Rust
126 lines
4.1 KiB
Rust
use std::sync::Arc;
|
|
use std::sync::Mutex;
|
|
use std::cmp::{min, max};
|
|
use std::time::Instant;
|
|
use cgmath::Vector3;
|
|
use std::thread;
|
|
use std::sync::{mpsc, mpsc::Receiver, mpsc::Sender};
|
|
use byteorder::{LittleEndian, ByteOrder};
|
|
|
|
pub const NODE_TEX_SIZE: usize = 128; // 32x32x32 nodes in texture
|
|
pub const NODE_TEX_SIZE_SQ: usize = NODE_TEX_SIZE*NODE_TEX_SIZE;
|
|
pub const NODE_TEX_SIZE_QB: usize = NODE_TEX_SIZE*NODE_TEX_SIZE*NODE_TEX_SIZE;
|
|
|
|
type NodeBuffer = (Vector3<i32>, Box<[u32]>);
|
|
|
|
pub struct Nodes {
|
|
buffer: Box<[u32]>,
|
|
offset: Vector3<i32>,
|
|
dirty: bool,
|
|
shift: Option<Vector3<i32>>,
|
|
working: bool,
|
|
channel: (Sender<NodeBuffer>, Receiver<NodeBuffer>)
|
|
}
|
|
|
|
impl Nodes {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
// Present
|
|
buffer: vec![0_u32; NODE_TEX_SIZE_QB].into_boxed_slice(),
|
|
offset: Vector3{x:0,y:0,z:0},
|
|
dirty: false,
|
|
|
|
shift: None,
|
|
working: false,
|
|
channel: mpsc::channel()
|
|
}
|
|
}
|
|
|
|
pub fn get_world_offset(&self) -> Vector3<i32> {
|
|
self.offset
|
|
}
|
|
|
|
pub fn get_node(&self, index: usize) -> u32 {
|
|
self.buffer[index]
|
|
}
|
|
|
|
pub fn is_busy(&self) -> bool {
|
|
self.shift != None
|
|
}
|
|
|
|
pub fn set_node(&mut self, index: usize, value: u32) {
|
|
self.buffer[index] = value;
|
|
self.dirty = true;
|
|
}
|
|
|
|
pub fn shift(&mut self, offset: &Vector3<i32>) {
|
|
if self.shift == None {
|
|
self.shift = Some(*offset);
|
|
} else {
|
|
println!("Tried to shift while another shifin was in progress");
|
|
}
|
|
}
|
|
|
|
pub fn update(&mut self, queue: &wgpu::Queue, texture: &wgpu::Texture) {
|
|
|
|
// Check if there is some more work
|
|
if !self.working {
|
|
if let Some(offset) = self.shift {
|
|
let source = self.buffer.clone();
|
|
let tx = self.channel.0.clone();
|
|
self.working = true;
|
|
|
|
// Spawn worker
|
|
thread::spawn(move || {
|
|
let size = NODE_TEX_SIZE as i32;
|
|
let mut target = vec![0_u32; NODE_TEX_SIZE_QB].into_boxed_slice();
|
|
let (ox, oy, oz) = (offset.x, offset.y, offset.z);
|
|
|
|
// Copy slice of source buffer into target buffer
|
|
for x in max(0, -ox)..min(size-ox, size) {
|
|
for y in max(0, -oy)..min(size-oy, size) {
|
|
for z in max(0, -oz)..min(size-oz, size) {
|
|
let idx0 = x + size * (y + size * z);
|
|
let idx1 = (x+ox) + size * ((y+oy) + size * (z+oz));
|
|
target[idx1 as usize] = source[idx0 as usize];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Send result
|
|
tx.send((offset, target)).unwrap();
|
|
});
|
|
}
|
|
}
|
|
|
|
// Receive work
|
|
while let Ok(result) = self.channel.1.try_recv() {
|
|
self.offset += result.0;
|
|
self.buffer = result.1;
|
|
self.shift = None;
|
|
self.dirty = true;
|
|
self.working = false;
|
|
}
|
|
|
|
if self.dirty {
|
|
self.dirty = false;
|
|
|
|
// Write all nodes to gpu
|
|
for z in 0..NODE_TEX_SIZE {
|
|
|
|
// Convert u32 node buffer to u8
|
|
let node_origin = wgpu::Origin3d{ x:0, y: 0, z: z as u32 };
|
|
let node_size = wgpu::Extent3d { width: NODE_TEX_SIZE as u32, height: NODE_TEX_SIZE as u32, depth: 1 };
|
|
let mut node_bytes = [0_u8; NODE_TEX_SIZE_SQ*4];
|
|
let offset = NODE_TEX_SIZE_SQ*z;
|
|
LittleEndian::write_u32_into(&self.buffer[offset..offset+NODE_TEX_SIZE_SQ], &mut node_bytes);
|
|
|
|
// Write nodes
|
|
queue.write_texture(
|
|
wgpu::TextureCopyView { texture: texture, mip_level: 0, origin: node_origin }, &node_bytes,
|
|
wgpu::TextureDataLayout { offset: 0, bytes_per_row: 4*node_size.width, rows_per_image: node_size.height }, node_size
|
|
);
|
|
}
|
|
}
|
|
}
|
|
} |