108 lines
3.3 KiB
Rust
108 lines
3.3 KiB
Rust
use std::time::Instant;
|
|
use flate2::Compression;
|
|
use flate2::write::DeflateEncoder;
|
|
use flate2::read::DeflateDecoder;
|
|
use byteorder::LittleEndian;
|
|
use byteorder::ByteOrder;
|
|
use cgmath::Point3;
|
|
use std::io::Write;
|
|
use std::convert::TryInto;
|
|
use std::io::Read;
|
|
use crate::game::world::{WorldBlock, block};
|
|
|
|
pub const SIZE: usize = 32;
|
|
const SIZE_SQ: usize = SIZE*SIZE;
|
|
const SIZE_QB: usize = SIZE*SIZE*SIZE;
|
|
|
|
pub struct WorldChunk {
|
|
nodes: Box<[u32]>,
|
|
blocks: Vec<WorldBlock>
|
|
}
|
|
|
|
impl WorldChunk {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
nodes: vec![0_u32; SIZE_QB as usize].into_boxed_slice(),
|
|
blocks: Vec::new()
|
|
}
|
|
}
|
|
|
|
pub fn from_bytes(bytes: Vec<u8>) -> Self {
|
|
let mut instance = Self::new();
|
|
let (node_bytes, block_bytes) = bytes.split_at((SIZE_QB*4) as usize);
|
|
|
|
// Nodes
|
|
let mut num_blocks = 0;
|
|
for i in 0..SIZE_QB {
|
|
let idx = (i*4) as usize;
|
|
let val = u32::from_le_bytes([node_bytes[idx], node_bytes[idx+1], node_bytes[idx+2], node_bytes[idx+3]]);
|
|
instance.nodes[i as usize] = val;
|
|
if val > 0 { num_blocks+=1; }
|
|
}
|
|
|
|
// Blocks
|
|
let mut decoder = DeflateDecoder::new(block_bytes);
|
|
let mut block_bytes = Vec::with_capacity(SIZE_QB);
|
|
decoder.read_to_end(&mut block_bytes).expect("Failed to decode");
|
|
|
|
for i in 0..num_blocks {
|
|
let mut block = WorldBlock::new();
|
|
let idx = i * block::SIZE_QB;
|
|
block.materials.clone_from_slice(&block_bytes[idx..idx+block::SIZE_QB]);
|
|
instance.blocks.push(block);
|
|
}
|
|
|
|
instance
|
|
}
|
|
|
|
pub fn all_blocks(&self) -> Vec<(Point3<u32>, &WorldBlock)> {
|
|
self.nodes.iter().enumerate()
|
|
.filter(|(_, n)| **n != 0)
|
|
.map(|(index, node)| {
|
|
|
|
let mut idx = index;
|
|
let z = idx / SIZE_SQ;
|
|
idx -= z * SIZE_SQ;
|
|
let y = idx / SIZE;
|
|
let x = idx % SIZE;
|
|
|
|
let pos = Point3{x: x as u32, y: y as u32, z: z as u32};
|
|
|
|
let block = &self.blocks[(*node-1) as usize];
|
|
(pos, block)
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
pub fn get_block(&mut self, block_pos: &Point3<u32>) -> &mut WorldBlock {
|
|
// Get block index
|
|
let index = (block_pos.x + SIZE as u32 * (block_pos.y + SIZE as u32 * block_pos.z)) as usize;
|
|
let mut value = self.nodes[index];
|
|
// Allocate new block
|
|
if value == 0 {
|
|
value = (self.blocks.len() + 1) as u32;
|
|
self.nodes[index] = value;
|
|
self.blocks.push(WorldBlock::new());
|
|
}
|
|
// Return block reference
|
|
&mut self.blocks[(value-1) as usize]
|
|
}
|
|
|
|
pub fn to_bytes(&self) -> Vec<u8> {
|
|
let mut bytes = Vec::with_capacity(self.nodes.len()*4 + self.blocks.len()* 32*32*32);
|
|
|
|
// Nodes
|
|
let mut node_bytes = [0_u8; (SIZE_QB*4) as usize];
|
|
LittleEndian::write_u32_into(&self.nodes, &mut node_bytes);
|
|
bytes.extend(node_bytes.iter());
|
|
|
|
// Blocks
|
|
let mut encoder = DeflateEncoder::new(Vec::new(), Compression::fast());
|
|
for block in self.blocks.iter() {
|
|
encoder.write_all(&block.materials).unwrap();
|
|
}
|
|
bytes.extend(encoder.finish().unwrap());
|
|
|
|
bytes
|
|
}
|
|
} |