piotrek/first-voxels
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

some code cleaning

Browse Source
This commit is contained in:
Piotrek
2021-05-18 14:53:04 +02:00
parent 5a62d8c70d
commit 9fb88c634b
4 changed files with 77 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/renderer/buffers/content.rs
+6 -2
View File
@@ -172,8 +172,12 @@ impl Content {
);
}
pub fn shift(&mut self, offset: &Vector3<i32>) -> bool {
self.nodes.shift(offset)
pub fn get_world_offset(&self) -> Vector3<i32> {
self.nodes.get_world_offset()
}
pub fn shift(&mut self, offset: &Vector3<i32>) {
self.nodes.shift(offset);
}
pub fn update(&mut self, queue: &wgpu::Queue) {
src/renderer/buffers/nodes.rs
+63 -27
View File
@@ -1,66 +1,102 @@
use std::sync::Arc;
use std::sync::Mutex;
use std::cmp::{min, max};
use std::time::Instant;
use cgmath::Vector3;
use std::thread;
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;
struct ShiftResult {
offset: Vector3<i32>,
active_buffer: usize
}
pub struct Nodes {
node_buffer: [Box<[u32]>; 2],
// Realtime variables
node_buffer: Arc<Mutex<[Box<[u32]>; 2]>>,
world_offset: Vector3<i32>,
active_buffer: usize,
modified: bool,
dirty: bool,
// Threaded work
busy: i32,
}
impl Nodes {
pub fn new() -> Self {
Self {
node_buffer: [vec![0_u32; NODE_TEX_SIZE_QB].into_boxed_slice(), vec![0_u32; NODE_TEX_SIZE_QB].into_boxed_slice()],
// Realtime variables
node_buffer: Arc::new(Mutex::new([vec![0_u32; NODE_TEX_SIZE_QB].into_boxed_slice(), vec![0_u32; NODE_TEX_SIZE_QB].into_boxed_slice()])),
world_offset: Vector3{x:0,y:0,z:0},
active_buffer: 0,
modified: false,
dirty: false,
// Threaded work
busy: 0,
}
}
pub fn get_world_offset(&self) -> Vector3<i32> {
self.world_offset
}
pub fn get_node(&self, index: usize) -> u32 {
self.node_buffer[self.active_buffer][index]
self.node_buffer.lock().unwrap()[self.active_buffer][index]
}
pub fn set_node(&mut self, index: usize, value: u32) {
self.node_buffer[self.active_buffer][index] = value;
self.modified = true;
self.node_buffer.lock().unwrap()[self.active_buffer][index] = value;
self.dirty = true;
}
pub fn shift(&mut self, offset: &Vector3<i32>) -> bool {
pub fn shift(&mut self, offset: &Vector3<i32>) {
let a = if self.active_buffer == 0 { 0 } else { 1 };
let b = if self.active_buffer == 0 { 1 } else { 0 };
let (ox, oy, oz) = (offset.x, offset.y, offset.z);
let size = NODE_TEX_SIZE as i32;
let node_buffer = Arc::clone(&self.node_buffer);
for i in self.node_buffer[b].iter_mut() {
*i = 0;
}
self.busy += 1;
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));
self.node_buffer[b][idx1 as usize] = self.node_buffer[a][idx0 as usize];
}
}
}
let t = thread::spawn(move || {
// Prepare variables
let mut node_buffer = node_buffer.lock().unwrap();
let size = NODE_TEX_SIZE as i32;
// Clear target buffer
for i in node_buffer[b].iter_mut() {
*i = 0;
}
// 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));
node_buffer[b][idx1 as usize] = node_buffer[a][idx0 as usize];
}
}
}
});
// DEBUG
t.join().unwrap();
self.world_offset += *offset;
self.active_buffer = b;
self.modified = true;
true
self.dirty = true;
self.busy -= 1;
}
pub fn update(&mut self, queue: &wgpu::Queue, texture: &wgpu::Texture) {
if self.modified {
self.modified = false;
if self.dirty {
self.dirty = false;
// Write all nodes to gpu
for z in 0..NODE_TEX_SIZE {
@@ -70,7 +106,7 @@ impl Nodes {
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.node_buffer[self.active_buffer][offset..offset+NODE_TEX_SIZE_SQ], &mut node_bytes);
LittleEndian::write_u32_into(&self.node_buffer.lock().unwrap()[self.active_buffer][offset..offset+NODE_TEX_SIZE_SQ], &mut node_bytes);
// Write nodes
queue.write_texture(
src/renderer/mod.rs
+6 -5
View File
@@ -26,8 +26,7 @@ pub struct Renderer {
buffers: Buffers,
// Other
pub camera: Camera,
start: std::time::Instant,
world_offset: Vector3<i32>
start: std::time::Instant
}
impl Renderer {
@@ -88,8 +87,7 @@ impl Renderer {
// Other
let start = std::time::Instant::now();
let world_offset = Vector3{x:0, y:0, z:0};
Self { surface, device, queue, swapchain_desc, swapchain, texture, raytrace_pass, postprocess_pass, ui, buffers, camera, start, world_offset }
Self { surface, device, queue, swapchain_desc, swapchain, texture, raytrace_pass, postprocess_pass, ui, buffers, camera, start }
}
/*
@@ -115,11 +113,14 @@ impl Renderer {
pub fn render(&mut self) -> Result<(), wgpu::SwapChainError> {
// Update uniform buffer
let off = self.buffers.content.get_world_offset();
let half = (buffers::nodes::NODE_TEX_SIZE / 2) as i32;
let cam_offset = Vector3{x: (self.world_offset.x + half) as f32, y: (self.world_offset.y + half) as f32, z: (self.world_offset.z + half) as f32 };
let cam_offset = Vector3{x: (off.x + half) as f32, y: (off.y + half) as f32, z: (off.z + half) as f32 };
self.buffers.uniforms.values.update(&self.camera, cam_offset, self.start.elapsed().as_secs_f32());
self.queue.write_buffer(&self.buffers.uniforms.buffer, 0, bytemuck::cast_slice(&[self.buffers.uniforms.values]));
// Update content
let timer = Instant::now();
self.buffers.content.update(&self.queue);
src/renderer/renderer_view.rs
+2 -8
View File
@@ -9,7 +9,6 @@ pub trait RendererView {
fn shift(&mut self, offset: Vector3<i32>);
fn get_camera_transform(&mut self) -> &mut dyn CameraTransform;
fn get_ui(&mut self) -> &mut UserInterface;
fn get_world_offset(&self) -> Vector3<i32>;
fn free_chunk(&mut self, chunk_pos: Vector3<i32>);
}
@@ -17,7 +16,7 @@ impl RendererView for Renderer {
fn write_chunk(&mut self, chunk_pos: &Vector3<i32>, chunk: &WorldChunk) -> bool {
// Calculate chunk position in renderer space
let chunk_off = self.world_offset / chunk::SIZE as i32;
let chunk_off = self.buffers.content.get_world_offset() / chunk::SIZE as i32;
let pos = chunk_pos + chunk_off;
// Make sure we are withing current world bounds
if pos.x.abs() > game::RENDER_DIST { println!("out of bounds! x: {} off: {:?} pos: {:?}", pos.x, chunk_off, chunk_pos); return false; }
@@ -50,8 +49,7 @@ impl RendererView for Renderer {
*/
fn shift(&mut self, offset: Vector3<i32>) {
self.buffers.content.shift(&-offset);
self.world_offset -= offset;
println!("World shifted by {:?}. World offset is now {:?}", offset, self.world_offset);
println!("World shifted by {:?}", offset);
}
fn get_camera_transform(&mut self) -> &mut dyn CameraTransform {
@@ -61,8 +59,4 @@ impl RendererView for Renderer {
fn get_ui(&mut self) -> &mut UserInterface {
&mut self.ui
}
fn get_world_offset(&self) -> Vector3<i32> {
self.world_offset
}
}