shadowcat/voxel-game
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

increase chunk size

Browse Source
This commit is contained in:
shadow cat
2024-09-15 12:14:24 -04:00
parent 177d7c6379
commit 3d0267f775
4 changed files with 47 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/client/render/voxel/ray_oct/compute.wgsl
View File

@@ -59,6 +59,9 @@ const FULL_ALPHA = 0.999;
const EPSILON = 0.00000000001; const EPSILON = 0.00000000001;
const MAX_ITERS = 1000; const MAX_ITERS = 1000;
const MAX_DEPTH: u32 = 10;
const MAX_LENGTH: u32 = (1u << MAX_DEPTH);
fn trace_full(pos_view: vec4<f32>, dir_view: vec4<f32>) -> vec4<f32> { fn trace_full(pos_view: vec4<f32>, dir_view: vec4<f32>) -> vec4<f32> {
let gi = 0; let gi = 0;
let group = voxel_groups[gi]; let group = voxel_groups[gi];
@@ -124,11 +127,11 @@ fn trace_full(pos_view: vec4<f32>, dir_view: vec4<f32>) -> vec4<f32> {
let inv_dir_bits = 7 - dir_bits; let inv_dir_bits = 7 - dir_bits;
var node_start = 1u; var node_start = 1u;
var scale = 7u; var scale = MAX_DEPTH - 1;
var half_t_span = f32(1u << scale) * inc_t; var half_t_span = f32(1u << scale) * inc_t;
var t_center = t_min + half_t_span; var t_center = t_min + half_t_span;
var color = vec4<f32>(0.0); var color = vec4<f32>(0.0);
var parents = array<u32, 8>(); var parents = array<u32, MAX_DEPTH>();
var child = (u32(t > t_center.x) << 2) + (u32(t > t_center.y) << 1) + u32(t > t_center.z); var child = (u32(t > t_center.x) << 2) + (u32(t > t_center.y) << 1) + u32(t > t_center.z);
var child_pos = dir_to_vec(child); var child_pos = dir_to_vec(child);
@@ -162,7 +165,7 @@ fn trace_full(pos_view: vec4<f32>, dir_view: vec4<f32>) -> vec4<f32> {
if (child & move_dir) > 0 { if (child & move_dir) > 0 {
// calculate new scale; first differing bit after adding // calculate new scale; first differing bit after adding
let new_pos = vox_pos[axis] + (1u << scale); let new_pos = vox_pos[axis] + (1u << scale);
if new_pos == 256 { break; } if new_pos == MAX_LENGTH { break; }
let differing = vox_pos[axis] ^ new_pos; let differing = vox_pos[axis] ^ new_pos;
vox_pos[axis] = new_pos; vox_pos[axis] = new_pos;
scale = firstLeadingBit(differing); scale = firstLeadingBit(differing);

2
src/client/render/voxel/ray_oct/layout.rs
View File

@@ -31,7 +31,7 @@ impl Layout {
"global lights", "global lights",
3, 3,
&[GlobalLight { &[GlobalLight {
direction: Vector3::new(-0.5, -4.0, 2.0).normalize(), direction: Vector3::new(-1.0, -2.0, 2.0).normalize(),
}], }],
); );
let texture = StorageTexture::init( let texture = StorageTexture::init(

5
src/common/component/chunk/mod.rs
View File

@@ -8,7 +8,8 @@ use bevy_derive::{Deref, DerefMut};
use bevy_ecs::{bundle::Bundle, component::Component, entity::Entity, system::Resource}; use bevy_ecs::{bundle::Bundle, component::Component, entity::Entity, system::Resource};
use nalgebra::Vector3; use nalgebra::Vector3;
pub const SIDE_LENGTH: usize = 16 * 16; pub const SIDE_POW: u32 = 10;
pub const SIDE_LENGTH: usize = 2usize.pow(SIDE_POW);
pub const SHAPE: (usize, usize, usize) = (SIDE_LENGTH, SIDE_LENGTH, SIDE_LENGTH); pub const SHAPE: (usize, usize, usize) = (SIDE_LENGTH, SIDE_LENGTH, SIDE_LENGTH);
pub const DIMENSIONS: Vector3<usize> = Vector3::new(SIDE_LENGTH, SIDE_LENGTH, SIDE_LENGTH); pub const DIMENSIONS: Vector3<usize> = Vector3::new(SIDE_LENGTH, SIDE_LENGTH, SIDE_LENGTH);
pub const LEN: usize = SHAPE.0 * SHAPE.1 * SHAPE.2; pub const LEN: usize = SHAPE.0 * SHAPE.1 * SHAPE.2;
@@ -25,7 +26,7 @@ impl ChunkData {
} }
pub fn empty() -> Self { pub fn empty() -> Self {
Self { Self {
data: OctTree::from_leaf(0, 8), data: OctTree::from_leaf(0, SIDE_POW),
} }
} }
} }

71
src/server/chunk/load.rs
View File

@@ -114,36 +114,37 @@ fn chunk_loader_main(channel: ThreadChannel<ServerChunkMsg, ChunkLoaderMsg>) {
let tree = ChunkData::from_tree(generate_tree(pos)); let tree = ChunkData::from_tree(generate_tree(pos));
let tree_time = std::time::Instant::now() - start; let tree_time = std::time::Instant::now() - start;
let start = std::time::Instant::now(); // let start = std::time::Instant::now();
let mut data = generate(pos); // let mut data = generate(pos);
let data_time = std::time::Instant::now() - start; // let data_time = std::time::Instant::now() - start;
//
let start = std::time::Instant::now(); // let start = std::time::Instant::now();
let shape = s![ // let shape = s![
1..data.len_of(Axis(0)) - 1, // 1..data.len_of(Axis(0)) - 1,
1..data.len_of(Axis(1)) - 1, // 1..data.len_of(Axis(1)) - 1,
1..data.len_of(Axis(2)) - 1 // 1..data.len_of(Axis(2)) - 1
]; // ];
let mut slice = data.slice_mut(shape); // let mut slice = data.slice_mut(shape);
let mut iter = tree.into_iter(); // let mut iter = tree.into_iter();
slice.assign(&Array3::from_shape_fn((256, 256, 256), |_| { // slice.assign(&Array3::from_shape_fn(chunk::SHAPE, |_| {
iter.next().unwrap() // iter.next().unwrap()
})); // }));
let convert_time = std::time::Instant::now() - start; // let convert_time = std::time::Instant::now() - start;
//
let start = std::time::Instant::now(); // let start = std::time::Instant::now();
let mesh = ChunkMesh::from_data(data.map(|i| COLOR_MAP[*i as usize]).view()); // let mesh = ChunkMesh::from_data(data.map(|i| COLOR_MAP[*i as usize]).view());
let mesh_time = std::time::Instant::now() - start; // let mesh_time = std::time::Instant::now() - start;
//
println!( // println!(
"data: {:<5?} mesh: {:<5?} convert: {:<5?} tree: {:<5?}", // "data: {:<5?} mesh: {:<5?} convert: {:<5?} tree: {:<5?}",
data_time, mesh_time, convert_time, tree_time // data_time, mesh_time, convert_time, tree_time
); // );
println!("gen time: {:<5?}", tree_time);
channel.send(ServerChunkMsg::ChunkGenerated(GeneratedChunk { channel.send(ServerChunkMsg::ChunkGenerated(GeneratedChunk {
pos, pos,
data: tree, data: tree,
mesh, mesh: ChunkMesh {},
})); }));
} }
ChunkLoaderMsg::Exit => { ChunkLoaderMsg::Exit => {
@@ -168,7 +169,9 @@ fn generate(pos: ChunkPos) -> Array3<u32> {
.with_seed(0) .with_seed(0)
.with_freq(0.005) .with_freq(0.005)
.generate(); .generate();
Array3::from_shape_fn(shape, |(x, y, z)| generate_at(Vector3::new(x, y, z), posf, &noise)) Array3::from_shape_fn(shape, |(x, y, z)| {
generate_at(Vector3::new(x, y, z), posf, &noise)
})
} }
fn generate_tree(pos: ChunkPos) -> OctTree { fn generate_tree(pos: ChunkPos) -> OctTree {
@@ -179,24 +182,24 @@ fn generate_tree(pos: ChunkPos) -> OctTree {
let (noise, ..) = let (noise, ..) =
NoiseBuilder::gradient_2d_offset(posf.x, chunk::SIDE_LENGTH, posf.z, chunk::SIDE_LENGTH) NoiseBuilder::gradient_2d_offset(posf.x, chunk::SIDE_LENGTH, posf.z, chunk::SIDE_LENGTH)
.with_seed(0) .with_seed(0)
.with_freq(0.005) .with_freq(0.01 / (chunk::SIDE_POW as f32))
.generate(); .generate();
OctTree::from_fn_rec(&mut |p| generate_at(p, posf, &noise), 8) OctTree::from_fn_rec(&mut |p| generate_at(p, posf, &noise), chunk::SIDE_POW)
} }
fn generate_at(p: Vector3<usize>, posf: Vector3<f32>, noise: &[f32]) -> u32 { fn generate_at(p: Vector3<usize>, posf: Vector3<f32>, noise: &[f32]) -> u32 {
// 0 air 1 stone 2 "sand" 3 water // 0 air 1 stone 2 "sand" 3 water
let y = p.y as f32 + posf.y; let y = p.y as f32 + posf.y;
let (_a, b, c, d) = (0.0, 50.0, 100.0, 127.0); let [a, b, c] = [0.20, 0.35, 0.5].map(|f| chunk::SIDE_LENGTH as f32 * f);
let n = (noise[p.x + p.z * chunk::SIDE_LENGTH] + 0.022) * (1.0 / 0.044) * d; let n = (noise[p.x + p.z * chunk::SIDE_LENGTH] + 0.022) * (1.0 / 0.044) * c;
if y < n.max(b) { if y < n.max(a) {
if y < b { if y < a {
if y > n { if y > n {
3 3
} else { } else {
1 1
} }
} else if y < c { } else if y < b {
2 2
} else { } else {
1 1