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

Fixed loading world, added saving meta data

Browse Source
This commit is contained in:
Piotrek
2021-05-09 16:27:04 +02:00
parent d0b7a781b4
commit 23d702ad6c
5 changed files with 105 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.lock
Generated
+11
View File
@@ -2287,12 +2287,14 @@ dependencies = [
"futures",
"glob",
"image",
"linked-hash-map",
"noise",
"rand 0.8.3",
"shaderc",
"wgpu",
"wgpu_glyph",
"winit",
"yaml-rust",
]
[[package]]
@@ -2426,3 +2428,12 @@ name = "xml-rs"
version = "0.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b07db065a5cf61a7e4ba64f29e67db906fb1787316516c4e6e5ff0fea1efcd8a"
[[package]]
name = "yaml-rust"
version = "0.4.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
dependencies = [
"linked-hash-map",
]
Cargo.toml
+2
View File
@@ -19,6 +19,8 @@ rand = "0.8"
noise = "0.7"
dirs = "3.0"
flate2 = "1.0"
yaml-rust = "0.4"
linked-hash-map = "0.5"
[build-dependencies]
anyhow = "1.0"
src/app/mod.rs
+18 -15
View File
@@ -28,23 +28,26 @@ impl App {
};
// let timer = Instant::now();
// for x in 0..16 {
// for z in 0..16 {
// let pos = &Point3{x,y:0,z};
// let block = app.world.gen_block(pos);
// content.write(pos, block);
// }
// }
// println!("Generated in {}", timer.elapsed().as_secs_f32());
// let timer = Instant::now();
// app.world.save();
// println!("Saved in {}", timer.elapsed().as_secs_f32());
let timer = Instant::now();
for x in 0..16 {
for z in 0..16 {
let pos = &Point3{x,y:0,z};
let block = app.world.gen_block(pos);
content.write(pos, block);
}
}
println!("Generated in {}", timer.elapsed().as_secs_f32());
let timer = Instant::now();
app.world.load();
println!("Loaded in {}", timer.elapsed().as_secs_f32());
app.world.save();
println!("Saved in {}", timer.elapsed().as_secs_f32());
// let timer = Instant::now();
// app.world.load();
// for (pos, block) in app.world.all_blocks() {
// content.write(&pos, block);
// }
// println!("Loaded in {}", timer.elapsed().as_secs_f32());
// let pos = &Point3{x:1,y:0,z:0};
// let block = app.world.gen_block(pos);
src/app/world/chunk.rs
+35 -13
View File
@@ -6,10 +6,12 @@ use byteorder::ByteOrder;
use cgmath::Point3;
use std::io::Write;
use std::convert::TryInto;
use std::io::Read;
use crate::app::world::{WorldBlock, block};
pub const SIZE: u32 = 32;
const SIZE_QB: u32 = SIZE*SIZE*SIZE;
pub const SIZE: usize = 32;
const SIZE_SQ: usize = SIZE*SIZE;
const SIZE_QB: usize = SIZE*SIZE*SIZE;
pub struct WorldChunk {
nodes: Box<[u32]>,
@@ -24,9 +26,28 @@ impl WorldChunk {
}
}
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 * (block_pos.y + SIZE * block_pos.z)) as usize;
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 {
@@ -47,15 +68,11 @@ impl WorldChunk {
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());
let mut encoder = DeflateEncoder::new(Vec::new(), Compression::fast());
for block in self.blocks.iter() {
bytes.extend(&block.materials);
encoder.write_all(&block.materials).unwrap();
}
bytes.extend(encoder.finish().unwrap());
bytes
}
@@ -65,14 +82,19 @@ impl WorldChunk {
let (node_bytes, block_bytes) = bytes.split_at((SIZE_QB*4) as usize);
// Nodes
let mut block_num = 0;
for i in 0..SIZE_QB {
let idx = (i*4) as usize;
instance.nodes[i as usize] = u32::from_le_bytes([node_bytes[idx], node_bytes[idx+1], node_bytes[idx+2], node_bytes[idx+3]]);
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 { block_num+=1; }
}
// Blocks
let block_num = block_bytes.len() / block::SIZE_QB;
println!("block_num {}", block_num);
let mut decoder = DeflateDecoder::new(block_bytes);
let mut block_bytes = Vec::new();
decoder.read_to_end(&mut block_bytes).expect("Failed to decode");
for i in 0..block_num {
let mut block = WorldBlock::new();
let idx = i * block::SIZE_QB;
src/app/world/mod.rs
+38 -7
View File
@@ -1,20 +1,23 @@
mod generator;
pub mod chunk;
pub mod block;
use linked_hash_map::LinkedHashMap;
use std::path::PathBuf;
use std::path::Path;
use std::io::Write;
use std::io::Read;
use std::fs;
use cgmath::Point3;
use cgmath::{Point3, InnerSpace};
use std::collections::HashMap;
use generator::WorldGen;
use chunk::WorldChunk;
use block::WorldBlock;
use yaml_rust::{Yaml, YamlLoader, YamlEmitter};
pub struct World {
name: String,
chunks: HashMap<Point3<u32>, WorldChunk>
chunks: HashMap<Point3<u32>, WorldChunk>,
}
impl World {
@@ -22,10 +25,23 @@ impl World {
pub fn new(name: String) -> Self {
Self {
name,
chunks: HashMap::new()
chunks: HashMap::new(),
}
}
pub fn all_blocks(&self) -> Vec<(Point3<u32>, &WorldBlock)> {
self.chunks.iter().map(|(chunk_pos, chunk)| {
let off = chunk_pos * chunk::SIZE as u32;
let result: Vec<(Point3<u32>, &WorldBlock)> = chunk.all_blocks().iter().map(|(pos, block)| {
(
Point3{x: off.x+pos.x, y: off.y+pos.y, z: off.z+pos.z},
*block
)
}).collect();
result
}).flatten().collect()
}
pub fn save(&self) {
// Get directory
let mut dir = dirs::data_local_dir().unwrap();
@@ -41,6 +57,18 @@ impl World {
let mut file = fs::File::create(path).expect("Failed to create file");
file.write(&bytes).unwrap();
}
// Save metadata
let mut data: LinkedHashMap<Yaml, Yaml> = LinkedHashMap::new();
data.insert(Yaml::String("name".to_string()), Yaml::String(self.name.clone()));
let mut data_str = String::new();
let mut emit = YamlEmitter::new(&mut data_str);
emit.dump(&Yaml::Hash(data)).expect("Failed to encode yaml");
let data_path: PathBuf = [dir.to_str().unwrap(), "world.yml"].iter().collect();
let mut data_file = fs::File::create(data_path).unwrap();
data_file.write_all(data_str.as_bytes()).expect("Failed to write");
}
pub fn load(&mut self) {
@@ -74,12 +102,15 @@ impl World {
println!("loaded {:?}", pos);
self.chunks.insert(pos, chunk);
}
// Load metadata
}
pub fn gen_block(&mut self, block_pos: &Point3<u32>) -> &WorldBlock {
// Split world space to chunk and block space
let ch_pos = block_pos / chunk::SIZE;
let bl_pos = block_pos % chunk::SIZE;
let ch_pos = block_pos / chunk::SIZE as u32;
let bl_pos = block_pos % chunk::SIZE as u32;
// Create chunk if does not exist
if let None = self.chunks.get(&ch_pos) {
self.chunks.insert(block_pos.clone(), WorldChunk::new());
@@ -94,8 +125,8 @@ impl World {
#[allow(unused)]
pub fn get_block(&mut self, block_pos: &Point3<u32>) -> Option<&WorldBlock> {
// Split world space to chunk and block space
let ch_pos = block_pos / chunk::SIZE;
let bl_pos = block_pos % chunk::SIZE;
let ch_pos = block_pos / chunk::SIZE as u32;
let bl_pos = block_pos % chunk::SIZE as u32;
// Return block if exists
if let Some(chunk) = self.chunks.get_mut(&ch_pos) {
return Some(chunk.get_block(&bl_pos));