379 lines
11 KiB
Rust
379 lines
11 KiB
Rust
extern crate alloc;
|
|
|
|
use alloc::vec;
|
|
use alloc::vec::Vec;
|
|
use core::ptr;
|
|
|
|
use crate::math::Vec3;
|
|
use crate::pxl8::*;
|
|
|
|
const CHUNK_SIZE: i32 = PXL8_VXL_CHUNK_SIZE as i32;
|
|
const CHUNK_VOLUME: usize = PXL8_VXL_CHUNK_VOLUME as usize;
|
|
const WORLD_CHUNK_SIZE: f32 = PXL8_VXL_WORLD_CHUNK_SIZE as f32;
|
|
const AIR: u8 = PXL8_VXL_BLOCK_AIR as u8;
|
|
const GRASS: u8 = 3;
|
|
const DIRT: u8 = 2;
|
|
const STONE: u8 = 1;
|
|
|
|
pub struct VoxelChunk {
|
|
pub chunk: *mut pxl8_vxl_chunk,
|
|
pub cx: i32,
|
|
pub cy: i32,
|
|
pub cz: i32,
|
|
}
|
|
|
|
impl VoxelChunk {
|
|
pub fn new(cx: i32, cy: i32, cz: i32) -> Self {
|
|
let chunk = unsafe { pxl8_vxl_chunk_create() };
|
|
Self { chunk, cx, cy, cz }
|
|
}
|
|
|
|
pub fn get(&self, x: i32, y: i32, z: i32) -> u8 {
|
|
if self.chunk.is_null() {
|
|
return AIR;
|
|
}
|
|
unsafe { pxl8_vxl_block_get(self.chunk, x, y, z) }
|
|
}
|
|
|
|
pub fn set(&mut self, x: i32, y: i32, z: i32, block: u8) {
|
|
if self.chunk.is_null() {
|
|
return;
|
|
}
|
|
unsafe { pxl8_vxl_block_set(self.chunk, x, y, z, block) }
|
|
}
|
|
|
|
pub fn fill(&mut self, block: u8) {
|
|
if self.chunk.is_null() {
|
|
return;
|
|
}
|
|
unsafe { pxl8_vxl_block_fill(self.chunk, block) }
|
|
}
|
|
|
|
pub fn is_uniform(&self) -> bool {
|
|
if self.chunk.is_null() {
|
|
return true;
|
|
}
|
|
unsafe { pxl8_vxl_chunk_is_uniform(self.chunk) }
|
|
}
|
|
|
|
pub fn rle_encode(&self) -> Vec<u8> {
|
|
if self.chunk.is_null() {
|
|
return Vec::new();
|
|
}
|
|
|
|
let mut linear = vec![0u8; CHUNK_VOLUME];
|
|
unsafe {
|
|
pxl8_vxl_chunk_linearize(self.chunk, linear.as_mut_ptr());
|
|
}
|
|
|
|
let mut result = Vec::new();
|
|
let mut i = 0;
|
|
|
|
while i < CHUNK_VOLUME {
|
|
let block = linear[i];
|
|
let mut run_len = 1usize;
|
|
|
|
while i + run_len < CHUNK_VOLUME
|
|
&& linear[i + run_len] == block
|
|
&& run_len < 256
|
|
{
|
|
run_len += 1;
|
|
}
|
|
|
|
result.push(block);
|
|
result.push((run_len - 1) as u8);
|
|
i += run_len;
|
|
}
|
|
|
|
result
|
|
}
|
|
}
|
|
|
|
impl Drop for VoxelChunk {
|
|
fn drop(&mut self) {
|
|
if !self.chunk.is_null() {
|
|
unsafe { pxl8_vxl_chunk_destroy(self.chunk) };
|
|
self.chunk = ptr::null_mut();
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Clone for VoxelChunk {
|
|
fn clone(&self) -> Self {
|
|
let new_chunk = Self::new(self.cx, self.cy, self.cz);
|
|
for z in 0..CHUNK_SIZE {
|
|
for y in 0..CHUNK_SIZE {
|
|
for x in 0..CHUNK_SIZE {
|
|
let block = self.get(x, y, z);
|
|
if block != AIR {
|
|
unsafe {
|
|
pxl8_vxl_block_set(new_chunk.chunk, x, y, z, block);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
new_chunk
|
|
}
|
|
}
|
|
|
|
pub struct VoxelWorld {
|
|
pub chunks: Vec<VoxelChunk>,
|
|
pub seed: u64,
|
|
}
|
|
|
|
impl VoxelWorld {
|
|
pub fn new(seed: u64) -> Self {
|
|
Self {
|
|
chunks: Vec::new(),
|
|
seed,
|
|
}
|
|
}
|
|
|
|
pub fn get_chunk(&self, cx: i32, cy: i32, cz: i32) -> Option<&VoxelChunk> {
|
|
self.chunks.iter().find(|c| c.cx == cx && c.cy == cy && c.cz == cz)
|
|
}
|
|
|
|
pub fn get_chunk_mut(&mut self, cx: i32, cy: i32, cz: i32) -> Option<&mut VoxelChunk> {
|
|
self.chunks.iter_mut().find(|c| c.cx == cx && c.cy == cy && c.cz == cz)
|
|
}
|
|
|
|
pub fn ensure_chunk(&mut self, cx: i32, cy: i32, cz: i32) -> &mut VoxelChunk {
|
|
if self.get_chunk(cx, cy, cz).is_none() {
|
|
let mut chunk = VoxelChunk::new(cx, cy, cz);
|
|
generate_chunk(&mut chunk, self.seed);
|
|
self.chunks.push(chunk);
|
|
}
|
|
self.get_chunk_mut(cx, cy, cz).unwrap()
|
|
}
|
|
|
|
pub fn world_to_chunk(x: f32) -> i32 {
|
|
libm::floorf(x / WORLD_CHUNK_SIZE) as i32
|
|
}
|
|
|
|
pub fn chunks_near(&self, pos: Vec3, radius: i32) -> Vec<(i32, i32, i32)> {
|
|
let cx = Self::world_to_chunk(pos.x);
|
|
let cy = Self::world_to_chunk(pos.y);
|
|
let cz = Self::world_to_chunk(pos.z);
|
|
|
|
let mut result = Vec::new();
|
|
for dz in -radius..=radius {
|
|
for dy in -radius..=radius {
|
|
for dx in -radius..=radius {
|
|
result.push((cx + dx, cy + dy, cz + dz));
|
|
}
|
|
}
|
|
}
|
|
result
|
|
}
|
|
|
|
pub fn load_chunks_around(&mut self, pos: Vec3, radius: i32) {
|
|
let coords = self.chunks_near(pos, radius);
|
|
for (cx, cy, cz) in coords {
|
|
self.ensure_chunk(cx, cy, cz);
|
|
}
|
|
}
|
|
|
|
pub fn find_surface_y(&mut self, world_x: f32, world_z: f32) -> f32 {
|
|
let scale = PXL8_VXL_SCALE as f32;
|
|
let block_x = libm::floorf(world_x / scale) as i32;
|
|
let block_z = libm::floorf(world_z / scale) as i32;
|
|
|
|
let cx = libm::floorf(block_x as f32 / CHUNK_SIZE as f32) as i32;
|
|
let cz = libm::floorf(block_z as f32 / CHUNK_SIZE as f32) as i32;
|
|
let lx = ((block_x % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE;
|
|
let lz = ((block_z % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE;
|
|
|
|
for cy in (-2..=2).rev() {
|
|
self.ensure_chunk(cx, cy, cz);
|
|
if let Some(chunk) = self.get_chunk(cx, cy, cz) {
|
|
for ly in (0..CHUNK_SIZE).rev() {
|
|
let block = chunk.get(lx, ly, lz);
|
|
if block == GRASS {
|
|
let world_y = (cy * CHUNK_SIZE + ly + 1) as f32 * scale;
|
|
return world_y;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
0.0
|
|
}
|
|
}
|
|
|
|
fn noise3d(x: i32, y: i32, z: i32, seed: u64) -> f32 {
|
|
let h = hash(seed ^ (x as u64) ^ ((y as u64) << 21) ^ ((z as u64) << 42));
|
|
(h & 0xFFFF) as f32 / 65535.0
|
|
}
|
|
|
|
fn hash(mut x: u64) -> u64 {
|
|
x ^= x >> 33;
|
|
x = x.wrapping_mul(0xff51afd7ed558ccd);
|
|
x ^= x >> 33;
|
|
x = x.wrapping_mul(0xc4ceb9fe1a85ec53);
|
|
x ^= x >> 33;
|
|
x
|
|
}
|
|
|
|
fn smoothstep(t: f32) -> f32 {
|
|
t * t * (3.0 - 2.0 * t)
|
|
}
|
|
|
|
fn lerp(a: f32, b: f32, t: f32) -> f32 {
|
|
a + (b - a) * t
|
|
}
|
|
|
|
fn value_noise_3d(x: f32, y: f32, z: f32, seed: u64) -> f32 {
|
|
let x0 = libm::floorf(x) as i32;
|
|
let y0 = libm::floorf(y) as i32;
|
|
let z0 = libm::floorf(z) as i32;
|
|
let x1 = x0 + 1;
|
|
let y1 = y0 + 1;
|
|
let z1 = z0 + 1;
|
|
|
|
let tx = smoothstep(x - x0 as f32);
|
|
let ty = smoothstep(y - y0 as f32);
|
|
let tz = smoothstep(z - z0 as f32);
|
|
|
|
let c000 = noise3d(x0, y0, z0, seed);
|
|
let c100 = noise3d(x1, y0, z0, seed);
|
|
let c010 = noise3d(x0, y1, z0, seed);
|
|
let c110 = noise3d(x1, y1, z0, seed);
|
|
let c001 = noise3d(x0, y0, z1, seed);
|
|
let c101 = noise3d(x1, y0, z1, seed);
|
|
let c011 = noise3d(x0, y1, z1, seed);
|
|
let c111 = noise3d(x1, y1, z1, seed);
|
|
|
|
let a00 = lerp(c000, c100, tx);
|
|
let a10 = lerp(c010, c110, tx);
|
|
let a01 = lerp(c001, c101, tx);
|
|
let a11 = lerp(c011, c111, tx);
|
|
|
|
let b0 = lerp(a00, a10, ty);
|
|
let b1 = lerp(a01, a11, ty);
|
|
|
|
lerp(b0, b1, tz)
|
|
}
|
|
|
|
fn fbm_3d(x: f32, y: f32, z: f32, seed: u64, octaves: u32) -> f32 {
|
|
let mut value = 0.0;
|
|
let mut amplitude = 1.0;
|
|
let mut frequency = 1.0;
|
|
let mut max_value = 0.0;
|
|
|
|
for i in 0..octaves {
|
|
value += amplitude * value_noise_3d(
|
|
x * frequency,
|
|
y * frequency,
|
|
z * frequency,
|
|
seed.wrapping_add(i as u64 * 1000)
|
|
);
|
|
max_value += amplitude;
|
|
amplitude *= 0.5;
|
|
frequency *= 2.0;
|
|
}
|
|
|
|
value / max_value
|
|
}
|
|
|
|
fn fbm_2d(x: f32, z: f32, seed: u64, octaves: u32) -> f32 {
|
|
let mut value = 0.0;
|
|
let mut amplitude = 1.0;
|
|
let mut frequency = 1.0;
|
|
let mut max_value = 0.0;
|
|
|
|
for i in 0..octaves {
|
|
let x0 = libm::floorf(x * frequency) as i32;
|
|
let z0 = libm::floorf(z * frequency) as i32;
|
|
let x1 = x0 + 1;
|
|
let z1 = z0 + 1;
|
|
|
|
let tx = smoothstep(x * frequency - x0 as f32);
|
|
let tz = smoothstep(z * frequency - z0 as f32);
|
|
|
|
let offset_seed = seed.wrapping_add(i as u64 * 1000);
|
|
let c00 = (hash(offset_seed ^ (x0 as u64) ^ ((z0 as u64) << 32)) & 0xFFFF) as f32 / 65535.0;
|
|
let c10 = (hash(offset_seed ^ (x1 as u64) ^ ((z0 as u64) << 32)) & 0xFFFF) as f32 / 65535.0;
|
|
let c01 = (hash(offset_seed ^ (x0 as u64) ^ ((z1 as u64) << 32)) & 0xFFFF) as f32 / 65535.0;
|
|
let c11 = (hash(offset_seed ^ (x1 as u64) ^ ((z1 as u64) << 32)) & 0xFFFF) as f32 / 65535.0;
|
|
|
|
let a = lerp(c00, c10, tx);
|
|
let b = lerp(c01, c11, tx);
|
|
value += amplitude * lerp(a, b, tz);
|
|
|
|
max_value += amplitude;
|
|
amplitude *= 0.5;
|
|
frequency *= 2.0;
|
|
}
|
|
|
|
value / max_value
|
|
}
|
|
|
|
fn generate_chunk(chunk: &mut VoxelChunk, seed: u64) {
|
|
let world_x = chunk.cx * CHUNK_SIZE;
|
|
let world_y = chunk.cy * CHUNK_SIZE;
|
|
let world_z = chunk.cz * CHUNK_SIZE;
|
|
|
|
let mut height_cache = [[0i32; 32]; 32];
|
|
for lz in 0..32 {
|
|
for lx in 0..32 {
|
|
let wx = (world_x + lx as i32) as f32;
|
|
let wz = (world_z + lz as i32) as f32;
|
|
height_cache[lz][lx] = (fbm_2d(wx * 0.02, wz * 0.02, seed, 4) * 32.0) as i32;
|
|
}
|
|
}
|
|
|
|
let mut density = [[[0.0f32; 33]; 33]; 33];
|
|
for lz in 0..33 {
|
|
for ly in 0..33 {
|
|
for lx in 0..33 {
|
|
let wx = (world_x + lx as i32) as f32;
|
|
let wy = (world_y + ly as i32) as f32;
|
|
let wz = (world_z + lz as i32) as f32;
|
|
|
|
let hx = lx.min(31);
|
|
let hz = lz.min(31);
|
|
let base_height = height_cache[hz][hx] as f32;
|
|
let height_bias = (base_height - wy) * 0.1;
|
|
|
|
let cave_noise = fbm_3d(wx * 0.05, wy * 0.05, wz * 0.05, seed.wrapping_add(1000), 2);
|
|
density[lz][ly][lx] = height_bias + (cave_noise - 0.55);
|
|
}
|
|
}
|
|
}
|
|
|
|
for lz in 0..CHUNK_SIZE {
|
|
for ly in 0..CHUNK_SIZE {
|
|
for lx in 0..CHUNK_SIZE {
|
|
let d = density[lz as usize][ly as usize][lx as usize];
|
|
if d <= 0.0 {
|
|
continue;
|
|
}
|
|
|
|
let d_above = density[lz as usize][(ly + 1) as usize][lx as usize];
|
|
let is_surface = d_above <= 0.0;
|
|
|
|
let block = if is_surface {
|
|
GRASS
|
|
} else {
|
|
let wy = world_y + ly;
|
|
let base_height = height_cache[lz as usize][lx as usize];
|
|
let depth = base_height - wy;
|
|
if depth < 4 {
|
|
DIRT
|
|
} else {
|
|
STONE
|
|
}
|
|
};
|
|
|
|
chunk.set(lx, ly, lz, block);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for VoxelWorld {
|
|
fn default() -> Self {
|
|
Self::new(12345)
|
|
}
|
|
}
|