4sides quad
This commit is contained in:
parent
534f1a109a
commit
7fe7015774
13 changed files with 784 additions and 52 deletions
src
548
src/scene.rs
548
src/scene.rs
|
@ -7,27 +7,32 @@ use cgmath::{vec2, vec3, Vector3};
|
|||
use std::cell::RefCell;
|
||||
use std::rc::Rc;
|
||||
|
||||
use std::time::Instant;
|
||||
|
||||
use crate::app_data::AppData;
|
||||
use crate::buffer;
|
||||
use crate::primitives::rec_cuboid::Cuboid;
|
||||
use crate::vertex;
|
||||
use crate::primitives::cube::Cube;
|
||||
use crate::primitives::quad::Quad;
|
||||
use crate::primitives::drawable::Drawable;
|
||||
|
||||
extern crate rand;
|
||||
use rand::Rng;
|
||||
|
||||
const CHUNK_SIZE_EXPONENT: u32 = 9;
|
||||
const CHUNK_SIZE_EXPONENT: u32 = 6;
|
||||
const CHUNK_SIZE: usize = (2 as usize).pow(CHUNK_SIZE_EXPONENT);
|
||||
const MAX_TREE_DEPTH: usize = 7;
|
||||
const MAX_TREE_DEPTH: usize = 4;
|
||||
const MIN_CHUNK_SIZE: usize = CHUNK_SIZE / (2 as usize).pow(MAX_TREE_DEPTH as u32);
|
||||
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct Scene {
|
||||
pub vertices: Vec<vertex::Vertex>,
|
||||
pub sized_vertices: Vec<vertex::SizedVertex>,
|
||||
pub rt_vertices: Vec<vertex::RTVertex>,
|
||||
pub indices_cube: Vec<u32>,
|
||||
pub indices_cuboid: Vec<u32>,
|
||||
pub indices_rt: Vec<u32>,
|
||||
|
||||
pub vertex_buffer_cube: vk::Buffer,
|
||||
pub vertex_buffer_memory_cube: vk::DeviceMemory,
|
||||
|
@ -40,18 +45,22 @@ pub struct Scene {
|
|||
|
||||
pub index_buffer_cuboid: vk::Buffer,
|
||||
pub index_buffer_memory_cuboid: vk::DeviceMemory,
|
||||
|
||||
pub vertex_buffer_quad: vk::Buffer,
|
||||
pub vertex_buffer_memory_quad: vk::DeviceMemory,
|
||||
|
||||
pub index_buffer_quad: vk::Buffer,
|
||||
pub index_buffer_memory_quad: vk::DeviceMemory,
|
||||
}
|
||||
|
||||
impl Scene {
|
||||
pub unsafe fn prepare_data(&mut self, instance: &vulkanalia::Instance, device: &vulkanalia::Device, data: &AppData) -> Result<()> {
|
||||
let mut rng = rand::thread_rng();
|
||||
let grid_size = 512; //CHUNK_SIZE as i32;
|
||||
let grid_size = CHUNK_SIZE as i32;
|
||||
|
||||
// todo store the chunks somewhere (or only use them as intermediary for neighbouthood calculation idc)
|
||||
let mut oct_tree: OctTree<Cube> = OctTree::create(CHUNK_SIZE)?;
|
||||
|
||||
//todo use the 14 vertice box method. Not using geometry shaders seems to be faster... make this a setting?
|
||||
// have cube elements with a method asking for vertices, while giving a primitive type -> method for preferred primitive type as well as one collecting all primitives
|
||||
for x_index in 0..grid_size {
|
||||
for y_index in 0..grid_size {
|
||||
let shade = (rng.gen_range(0..25) as f32) / 100.0;
|
||||
|
@ -65,8 +74,18 @@ impl Scene {
|
|||
}
|
||||
}
|
||||
|
||||
let mut test = EmptyVolume::from_oct_tree(&oct_tree);
|
||||
println!("number of empty volumes is {}", test.len());
|
||||
let shade = (rng.gen_range(0..25) as f32) / 100.0;
|
||||
let cube = Cube {
|
||||
pos: vec3(10.0, 10.0, 10.0),
|
||||
color: vec3(shade, 1.0, shade),
|
||||
tex_coord: vec2(0.0, 0.0)
|
||||
};
|
||||
|
||||
oct_tree.set_cube(cube.clone());
|
||||
|
||||
let mut empty_volumes: Vec<Rc<RefCell<EmptyVolume>>>;
|
||||
(empty_volumes, _) = EmptyVolume::from_oct_tree(&oct_tree);
|
||||
println!("number of empty volumes is {}", empty_volumes.len());
|
||||
|
||||
let oct_tree_iter = OctTreeIter::create(&oct_tree)?;
|
||||
for item in oct_tree_iter {
|
||||
|
@ -74,7 +93,7 @@ impl Scene {
|
|||
let index = self.vertices.len();
|
||||
match item {
|
||||
Some(cube) => {
|
||||
if (cube.pos.x + cube.pos.y) as usize % 2 == 0{
|
||||
/*if (cube.pos.x + cube.pos.y) as usize % 2 == 0{
|
||||
/**/
|
||||
let cuboid = Cuboid {
|
||||
pos: cube.pos,
|
||||
|
@ -86,11 +105,19 @@ impl Scene {
|
|||
}
|
||||
else {
|
||||
cube.draw(&data.topology, index, self);
|
||||
}
|
||||
}*/
|
||||
cube.draw(&data.topology, index, self);
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
}
|
||||
|
||||
for volume in empty_volumes {
|
||||
let quads = volume.borrow().to_quads();
|
||||
for quad in quads {
|
||||
quad.draw(&data.topology, self.rt_vertices.len(), self);
|
||||
}
|
||||
}
|
||||
|
||||
if self.vertices.len() != 0 {
|
||||
(self.vertex_buffer_cube, self.vertex_buffer_memory_cube) = buffer::create_vertex_buffer(instance, device, &data, &self.vertices)?;
|
||||
|
@ -102,6 +129,11 @@ impl Scene {
|
|||
(self.index_buffer_cuboid, self.index_buffer_memory_cuboid) = buffer::create_index_buffer(&instance, &device, &data, &self.indices_cuboid)?;
|
||||
}
|
||||
|
||||
if self.rt_vertices.len() != 0 {
|
||||
(self.vertex_buffer_quad, self.vertex_buffer_memory_quad) = buffer::create_vertex_buffer(instance, device, &data, &self.rt_vertices)?;
|
||||
(self.index_buffer_quad, self.index_buffer_memory_quad) = buffer::create_index_buffer(&instance, &device, &data, &self.indices_rt)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
|
||||
}
|
||||
|
@ -117,7 +149,13 @@ impl Scene {
|
|||
device.free_memory(self.index_buffer_memory_cuboid, None);
|
||||
|
||||
device.destroy_buffer(self.vertex_buffer_cuboid, None);
|
||||
device.free_memory(self.vertex_buffer_memory_cuboid, None);
|
||||
device.free_memory(self.vertex_buffer_memory_cuboid, None);
|
||||
|
||||
device.destroy_buffer(self.index_buffer_quad, None);
|
||||
device.free_memory(self.index_buffer_memory_quad, None);
|
||||
|
||||
device.destroy_buffer(self.vertex_buffer_quad, None);
|
||||
device.free_memory(self.vertex_buffer_memory_quad, None);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -617,22 +655,22 @@ struct EmptyVolume {
|
|||
pub color_back: Vec<Vector3<u8>>,
|
||||
pub color_top: Vec<Vector3<u8>>,
|
||||
pub color_bottom: Vec<Vector3<u8>>,
|
||||
pub color_left: Vec<Vector3<u8>>,
|
||||
pub color_right: Vec<Vector3<u8>>,
|
||||
pub color_back_rn: Vec<Vector3<u8>>,
|
||||
pub color_front_rn: Vec<Vector3<u8>>,
|
||||
|
||||
pub roughness_front: Vec<Vector3<u8>>,
|
||||
pub roughness_back: Vec<Vector3<u8>>,
|
||||
pub roughness_top: Vec<Vector3<u8>>,
|
||||
pub roughness_bottom: Vec<Vector3<u8>>,
|
||||
pub roughness_left: Vec<Vector3<u8>>,
|
||||
pub roughness_right: Vec<Vector3<u8>>,
|
||||
pub roughness_back_rn: Vec<Vector3<u8>>,
|
||||
pub roughness_front_rn: Vec<Vector3<u8>>,
|
||||
|
||||
pub neighbor_front: Vec<Rc<RefCell<Self>>>,
|
||||
pub neighbor_back: Vec<Rc<RefCell<Self>>>,
|
||||
pub neighbor_top: Vec<Rc<RefCell<Self>>>,
|
||||
pub neighbor_bottom: Vec<Rc<RefCell<Self>>>,
|
||||
pub neighbor_left: Vec<Rc<RefCell<Self>>>,
|
||||
pub neighbor_right: Vec<Rc<RefCell<Self>>>,
|
||||
pub neighbor_front: Vec<Option<Rc<RefCell<Self>>>>,
|
||||
pub neighbor_back: Vec<Option<Rc<RefCell<Self>>>>,
|
||||
pub neighbor_top: Vec<Option<Rc<RefCell<Self>>>>,
|
||||
pub neighbor_bottom: Vec<Option<Rc<RefCell<Self>>>>,
|
||||
pub neighbor_back_rn: Vec<Option<Rc<RefCell<Self>>>>,
|
||||
pub neighbor_front_rn: Vec<Option<Rc<RefCell<Self>>>>,
|
||||
}
|
||||
|
||||
impl EmptyVolume {
|
||||
|
@ -642,11 +680,12 @@ impl EmptyVolume {
|
|||
self.position[2] + self.size_z > pos[2] && pos[2] >= self.position[2]
|
||||
}
|
||||
|
||||
pub fn from_oct_tree(tree: &OctTree<Cube>) -> Vec<Rc<RefCell<EmptyVolume>>> {
|
||||
pub fn from_oct_tree(tree: &OctTree<Cube>) -> (Vec<Rc<RefCell<EmptyVolume>>>, OctTree<Rc<RefCell<EmptyVolume>>>) {
|
||||
// todo: ppotentially use a child exist check while going through the oct tree to find some obvios starting empty volumes. Will still need to check for possible expansions though
|
||||
let mut volumes: Vec<Rc<RefCell<EmptyVolume>>> = vec![];
|
||||
|
||||
let mut neighbors: OctTree<Rc<RefCell<EmptyVolume>>> = OctTree::create(tree.size).unwrap();
|
||||
|
||||
let start_time = Instant::now();
|
||||
// iterate over all block positions in the oct tree
|
||||
for x_index in 0..tree.size {
|
||||
for y_index in 0..tree.size {
|
||||
|
@ -664,6 +703,7 @@ impl EmptyVolume {
|
|||
for volume in &volumes {
|
||||
if volume.borrow().contains(&Vector3{x: x_index, y: y_index, z: z_index}) {
|
||||
contained = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if contained {
|
||||
|
@ -736,20 +776,20 @@ impl EmptyVolume {
|
|||
color_back: vec![],
|
||||
color_top: vec![],
|
||||
color_bottom: vec![],
|
||||
color_left: vec![],
|
||||
color_right: vec![],
|
||||
color_back_rn: vec![],
|
||||
color_front_rn: vec![],
|
||||
roughness_front: vec![],
|
||||
roughness_back: vec![],
|
||||
roughness_top: vec![],
|
||||
roughness_bottom: vec![],
|
||||
roughness_left: vec![],
|
||||
roughness_right: vec![],
|
||||
roughness_back_rn: vec![],
|
||||
roughness_front_rn: vec![],
|
||||
neighbor_front: vec![],
|
||||
neighbor_back: vec![],
|
||||
neighbor_top: vec![],
|
||||
neighbor_bottom: vec![],
|
||||
neighbor_left: vec![],
|
||||
neighbor_right: vec![],
|
||||
neighbor_back_rn: vec![],
|
||||
neighbor_front_rn: vec![],
|
||||
};
|
||||
println!("adding neighbor references");
|
||||
//fill in info in the neighbor octtree
|
||||
|
@ -757,12 +797,202 @@ impl EmptyVolume {
|
|||
for x in 0..x_size+1 {
|
||||
for y in 0..y_size+1 {
|
||||
for z in 0..z_size+1 {
|
||||
// fill only the edges
|
||||
if x == 0 || x == x_size || y == 0 || y == y_size || z==0 || z == z_size {
|
||||
neighbors.set_element(reference.clone(), reference.borrow().position.x + x, reference.borrow().position.y + y, reference.borrow().position.z + z)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
println!("add the border information for color and roughness");
|
||||
let x_min_pos;
|
||||
if reference.borrow().position.x == 0 {
|
||||
// will result in an empty color and roughness map.
|
||||
x_min_pos = 0;
|
||||
}
|
||||
else {
|
||||
x_min_pos = reference.borrow().position.x -1;
|
||||
}
|
||||
let y_min_pos;
|
||||
if reference.borrow().position.y == 0 {
|
||||
// will result in an empty color and roughness map.
|
||||
y_min_pos = 0;
|
||||
}
|
||||
else {
|
||||
y_min_pos = reference.borrow().position.y -1;
|
||||
}
|
||||
let z_min_pos;
|
||||
if reference.borrow().position.z == 0 {
|
||||
// will result in an empty color and roughness map.
|
||||
z_min_pos = 0;
|
||||
}
|
||||
else {
|
||||
z_min_pos = reference.borrow().position.z -1;
|
||||
}
|
||||
let x_max_pos = reference.borrow().position.x + reference.borrow().size_x;
|
||||
let y_max_pos = reference.borrow().position.y + reference.borrow().size_y;
|
||||
let z_max_pos = reference.borrow().position.z + reference.borrow().size_z;
|
||||
// bottom face of the volume
|
||||
let mut bottom_colors = vec![];
|
||||
let mut bottom_roughness = vec![];
|
||||
let mut bottom_elements_num = 0;
|
||||
for x in 0..x_size+1 {
|
||||
for y in 0..y_size+1 {
|
||||
if let Some(c) = tree.get_element(reference.borrow().position.x + x, reference.borrow().position.y + y, z_min_pos) {
|
||||
bottom_elements_num += 1;
|
||||
let u8_color = Vector3 {x: (c.color * 255.0).x.min(255.0).max(0.0) as u8, y: (c.color * 255.0).y.min(255.0).max(0.0) as u8, z: (c.color * 255.0).z.min(255.0).max(0.0) as u8};
|
||||
bottom_colors.push(u8_color);
|
||||
bottom_roughness.push(Vector3 {x: 128, y: 128, z: 128});
|
||||
}
|
||||
else {
|
||||
bottom_colors.push(Vector3 { x: 255, y: 255, z: 255 });
|
||||
bottom_roughness.push(Vector3 {x: 255, y: 255, z: 255});
|
||||
}
|
||||
}
|
||||
}
|
||||
if bottom_elements_num > 0 {
|
||||
reference.borrow_mut().color_bottom = bottom_colors;
|
||||
reference.borrow_mut().roughness_bottom = bottom_roughness;
|
||||
}
|
||||
else {
|
||||
reference.borrow_mut().color_bottom= vec![];
|
||||
reference.borrow_mut().roughness_bottom= vec![];
|
||||
}
|
||||
// top face of the volume
|
||||
let mut top_colors = vec![];
|
||||
let mut top_roughness = vec![];
|
||||
let mut top_elements_num = 0;
|
||||
for x in 0..x_size+1 {
|
||||
for y in 0..y_size+1 {
|
||||
if let Some(c) = tree.get_element(reference.borrow().position.x + x, reference.borrow().position.y + y, z_max_pos) {
|
||||
top_elements_num += 1;
|
||||
let u8_color = Vector3 {x: (c.color * 255.0).x.min(255.0).max(0.0) as u8, y: (c.color * 255.0).y.min(255.0).max(0.0) as u8, z: (c.color * 255.0).z.min(255.0).max(0.0) as u8};
|
||||
top_colors.push(u8_color);
|
||||
top_roughness.push(Vector3 {x: 128, y: 128, z: 128});
|
||||
}
|
||||
else {
|
||||
top_colors.push(Vector3 { x: 255, y: 255, z: 255 });
|
||||
top_roughness.push(Vector3 {x: 255, y: 255, z: 255});
|
||||
}
|
||||
}
|
||||
}
|
||||
if top_elements_num > 0 {
|
||||
reference.borrow_mut().color_top = top_colors;
|
||||
reference.borrow_mut().roughness_top = top_roughness;
|
||||
}
|
||||
else {
|
||||
reference.borrow_mut().color_top= vec![];
|
||||
reference.borrow_mut().roughness_top= vec![];
|
||||
}
|
||||
|
||||
// back face of the volume
|
||||
let mut back_colors_rn = vec![];
|
||||
let mut back_roughness_rn = vec![];
|
||||
let mut back_elements_num_rn = 0;
|
||||
for x in 0..x_size+1 {
|
||||
for z in 0..z_size+1 {
|
||||
if let Some(c) = tree.get_element(reference.borrow().position.x + x, y_max_pos, reference.borrow().position.z + z) {
|
||||
back_elements_num_rn += 1;
|
||||
let u8_color = Vector3 {x: (c.color * 255.0).x.min(255.0).max(0.0) as u8, y: (c.color * 255.0).y.min(255.0).max(0.0) as u8, z: (c.color * 255.0).z.min(255.0).max(0.0) as u8};
|
||||
back_colors_rn.push(u8_color);
|
||||
back_roughness_rn.push(Vector3 {x: 128, y: 128, z: 128});
|
||||
}
|
||||
else {
|
||||
back_colors_rn.push(Vector3 { x: 255, y: 255, z: 255 });
|
||||
back_roughness_rn.push(Vector3 {x: 255, y: 255, z: 255});
|
||||
}
|
||||
}
|
||||
}
|
||||
if back_elements_num_rn > 0 {
|
||||
reference.borrow_mut().color_back_rn = back_colors_rn;
|
||||
reference.borrow_mut().roughness_back_rn = back_roughness_rn;
|
||||
}
|
||||
else {
|
||||
reference.borrow_mut().color_back_rn= vec![];
|
||||
reference.borrow_mut().roughness_back_rn= vec![];
|
||||
}
|
||||
|
||||
// front face of the volume
|
||||
let mut front_colors_rn = vec![];
|
||||
let mut front_roughness_rn = vec![];
|
||||
let mut front_elements_num_rn = 0;
|
||||
for x in 0..x_size+1 {
|
||||
for z in 0..z_size+1 {
|
||||
if let Some(c) = tree.get_element(reference.borrow().position.x + x, y_min_pos, reference.borrow().position.z + z) {
|
||||
front_elements_num_rn += 1;
|
||||
let u8_color = Vector3 {x: (c.color * 255.0).x.min(255.0).max(0.0) as u8, y: (c.color * 255.0).y.min(255.0).max(0.0) as u8, z: (c.color * 255.0).z.min(255.0).max(0.0) as u8};
|
||||
front_colors_rn.push(u8_color);
|
||||
front_roughness_rn.push(Vector3 {x: 128, y: 128, z: 128});
|
||||
}
|
||||
else {
|
||||
front_colors_rn.push(Vector3 { x: 255, y: 255, z: 255 });
|
||||
front_roughness_rn.push(Vector3 {x: 255, y: 255, z: 255});
|
||||
}
|
||||
}
|
||||
}
|
||||
if front_elements_num_rn > 0 {
|
||||
reference.borrow_mut().color_front_rn = front_colors_rn;
|
||||
reference.borrow_mut().roughness_front_rn = front_roughness_rn;
|
||||
}
|
||||
else {
|
||||
reference.borrow_mut().color_front_rn= vec![];
|
||||
reference.borrow_mut().roughness_front_rn= vec![];
|
||||
}
|
||||
|
||||
// front face of the volume
|
||||
let mut front_colors = vec![];
|
||||
let mut front_roughness = vec![];
|
||||
let mut front_elements_num = 0;
|
||||
for y in 0..y_size+1 {
|
||||
for z in 0..z_size+1 {
|
||||
if let Some(c) = tree.get_element(x_min_pos, reference.borrow().position.y + y, reference.borrow().position.z + z) {
|
||||
front_elements_num += 1;
|
||||
let u8_color = Vector3 {x: (c.color * 255.0).x.min(255.0).max(0.0) as u8, y: (c.color * 255.0).y.min(255.0).max(0.0) as u8, z: (c.color * 255.0).z.min(255.0).max(0.0) as u8};
|
||||
front_colors.push(u8_color);
|
||||
front_roughness.push(Vector3 {x: 128, y: 128, z: 128});
|
||||
}
|
||||
else {
|
||||
front_colors.push(Vector3 { x: 255, y: 255, z: 255 });
|
||||
front_roughness.push(Vector3 {x: 255, y: 255, z: 255});
|
||||
}
|
||||
}
|
||||
}
|
||||
if front_elements_num > 0 {
|
||||
reference.borrow_mut().color_front = front_colors;
|
||||
reference.borrow_mut().roughness_front = front_roughness;
|
||||
}
|
||||
else {
|
||||
reference.borrow_mut().color_front= vec![];
|
||||
reference.borrow_mut().roughness_front= vec![];
|
||||
}
|
||||
|
||||
// back face of the volume
|
||||
let mut back_colors = vec![];
|
||||
let mut back_roughness = vec![];
|
||||
let mut back_elements_num = 0;
|
||||
for y in 0..y_size+1 {
|
||||
for z in 0..z_size+1 {
|
||||
if let Some(c) = tree.get_element(x_max_pos, reference.borrow().position.y + y, reference.borrow().position.z + z) {
|
||||
back_elements_num += 1;
|
||||
let u8_color = Vector3 {x: (c.color * 255.0).x.min(255.0).max(0.0) as u8, y: (c.color * 255.0).y.min(255.0).max(0.0) as u8, z: (c.color * 255.0).z.min(255.0).max(0.0) as u8};
|
||||
back_colors.push(u8_color);
|
||||
back_roughness.push(Vector3 {x: 128, y: 128, z: 128});
|
||||
}
|
||||
else {
|
||||
back_colors.push(Vector3 { x: 255, y: 255, z: 255 });
|
||||
back_roughness.push(Vector3 {x: 255, y: 255, z: 255});
|
||||
}
|
||||
}
|
||||
}
|
||||
if back_elements_num > 0 {
|
||||
reference.borrow_mut().color_back = back_colors;
|
||||
reference.borrow_mut().roughness_back = back_roughness;
|
||||
}
|
||||
else {
|
||||
reference.borrow_mut().color_back= vec![];
|
||||
reference.borrow_mut().roughness_back= vec![];
|
||||
}
|
||||
|
||||
println!("new volume done");
|
||||
//push to the list
|
||||
volumes.push(reference);
|
||||
|
@ -771,8 +1001,268 @@ impl EmptyVolume {
|
|||
}
|
||||
}
|
||||
}
|
||||
println!("add the neighbor linkage for all the volumes of the oct tree");
|
||||
for reference in volumes.iter_mut() {
|
||||
let x_min_pos;
|
||||
if reference.borrow().position.x == 0 {
|
||||
// will result in an empty color and roughness map.
|
||||
x_min_pos = 0;
|
||||
}
|
||||
else {
|
||||
x_min_pos = reference.borrow().position.x -1;
|
||||
}
|
||||
let y_min_pos;
|
||||
if reference.borrow().position.y == 0 {
|
||||
// will result in an empty color and roughness map.
|
||||
y_min_pos = 0;
|
||||
}
|
||||
else {
|
||||
y_min_pos = reference.borrow().position.y -1;
|
||||
}
|
||||
let z_min_pos;
|
||||
if reference.borrow().position.z == 0 {
|
||||
// will result in an empty color and roughness map.
|
||||
z_min_pos = 0;
|
||||
}
|
||||
else {
|
||||
z_min_pos = reference.borrow().position.z -1;
|
||||
}
|
||||
let x_max_pos = reference.borrow().position.x + reference.borrow().size_x;
|
||||
let y_max_pos = reference.borrow().position.y + reference.borrow().size_y;
|
||||
let z_max_pos = reference.borrow().position.z + reference.borrow().size_z;
|
||||
// bottom face of the volume
|
||||
let mut bottom_neighbors = vec![];
|
||||
let mut bottom_elements_num = 0;
|
||||
if z_min_pos != 0 {
|
||||
for x in 0..reference.borrow().size_x {
|
||||
for y in 0..reference.borrow().size_y {
|
||||
if let Some(c) = neighbors.get_element(reference.borrow().position.x + x, reference.borrow().position.y + y, z_min_pos) {
|
||||
bottom_elements_num += 1;
|
||||
bottom_neighbors.push(Some(c.clone()));
|
||||
}
|
||||
else {
|
||||
bottom_neighbors.push(None);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if bottom_elements_num > 0 {
|
||||
reference.borrow_mut().neighbor_bottom = bottom_neighbors;
|
||||
}
|
||||
else {
|
||||
reference.borrow_mut().neighbor_bottom = vec![None];
|
||||
}
|
||||
// top face of the volume
|
||||
let mut top_neighbors = vec![];
|
||||
let mut top_elements_num = 0;
|
||||
for x in 0..reference.borrow().size_x {
|
||||
for y in 0..reference.borrow().size_y {
|
||||
if let Some(c) = neighbors.get_element(reference.borrow().position.x + x, reference.borrow().position.y + y, z_max_pos) {
|
||||
top_elements_num += 1;
|
||||
top_neighbors.push(Some(c.clone()));
|
||||
}
|
||||
else {
|
||||
top_neighbors.push(None);
|
||||
}
|
||||
}
|
||||
}
|
||||
if top_elements_num > 0 {
|
||||
reference.borrow_mut().neighbor_top = top_neighbors;
|
||||
}
|
||||
else {
|
||||
reference.borrow_mut().neighbor_top = vec![None];
|
||||
}
|
||||
|
||||
volumes
|
||||
// left face of the volume
|
||||
let mut back_neighbors_rn = vec![];
|
||||
let mut back_elements_num_rn = 0;
|
||||
for x in 0..reference.borrow().size_x {
|
||||
for z in 0..reference.borrow().size_z {
|
||||
if let Some(c) = neighbors.get_element(reference.borrow().position.x + x, y_max_pos, reference.borrow().position.z + z) {
|
||||
back_elements_num_rn += 1;
|
||||
back_neighbors_rn.push(Some(c.clone()));
|
||||
}
|
||||
else {
|
||||
back_neighbors_rn.push(None);
|
||||
}
|
||||
}
|
||||
}
|
||||
if back_elements_num_rn > 0 {
|
||||
reference.borrow_mut().neighbor_back_rn = back_neighbors_rn;
|
||||
}
|
||||
else {
|
||||
reference.borrow_mut().neighbor_back_rn = vec![None];
|
||||
}
|
||||
|
||||
// right face of the volume
|
||||
let mut front_neighbors_rn = vec![];
|
||||
let mut front_elements_num_rn = 0;
|
||||
if y_min_pos != 0{
|
||||
for x in 0..reference.borrow().size_x {
|
||||
for z in 0..reference.borrow().size_z {
|
||||
if let Some(c) = neighbors.get_element(reference.borrow().position.x + x, y_min_pos, reference.borrow().position.z + z) {
|
||||
front_elements_num_rn += 1;
|
||||
front_neighbors_rn.push(Some(c.clone()));
|
||||
}
|
||||
else {
|
||||
front_neighbors_rn.push(None);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if front_elements_num_rn > 0 {
|
||||
reference.borrow_mut().neighbor_front_rn = front_neighbors_rn;
|
||||
}
|
||||
else {
|
||||
reference.borrow_mut().neighbor_front_rn = vec![None];
|
||||
}
|
||||
|
||||
// front face of the volume
|
||||
let mut front_neighbors = vec![];
|
||||
let mut front_elements_num = 0;
|
||||
if x_min_pos != 0 {
|
||||
for y in 0..reference.borrow().size_y {
|
||||
for z in 0..reference.borrow().size_z {
|
||||
if let Some(c) = neighbors.get_element(x_min_pos, reference.borrow().position.y + y, reference.borrow().position.z + z) {
|
||||
front_elements_num += 1;
|
||||
front_neighbors.push(Some(c.clone()));
|
||||
}
|
||||
else {
|
||||
front_neighbors.push(None);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if front_elements_num > 0 {
|
||||
reference.borrow_mut().neighbor_front = front_neighbors;
|
||||
}
|
||||
else {
|
||||
reference.borrow_mut().neighbor_front = vec![None];
|
||||
}
|
||||
|
||||
// back face of the volume
|
||||
let mut back_neighbors = vec![];
|
||||
let mut back_elements_num = 0;
|
||||
for y in 0..reference.borrow().size_y {
|
||||
for z in 0..reference.borrow().size_z {
|
||||
if let Some(c) = neighbors.get_element(x_max_pos, reference.borrow().position.y + y, reference.borrow().position.z + z) {
|
||||
back_elements_num += 1;
|
||||
back_neighbors.push(Some(c.clone()));
|
||||
}
|
||||
else {
|
||||
back_neighbors.push(None);
|
||||
}
|
||||
}
|
||||
}
|
||||
if back_elements_num > 0 {
|
||||
reference.borrow_mut().neighbor_back = back_neighbors;
|
||||
}
|
||||
else {
|
||||
reference.borrow_mut().neighbor_back = vec![None];
|
||||
}
|
||||
}
|
||||
println!("volume creation took {} s", start_time.elapsed().as_millis() as f32 / 1000.0);
|
||||
(volumes, neighbors)
|
||||
}
|
||||
|
||||
fn to_quads(&self) -> Vec<Quad> {
|
||||
let mut quads = vec![];
|
||||
let float_pos = Vector3 {x: self.position.x as f32, y: self.position.y as f32, z: self.position.z as f32};
|
||||
//bottom sides of the volumes, top side of the block
|
||||
for x in 0..self.size_x {
|
||||
for y in 0..self.size_y {
|
||||
let index = x * self.size_y + y;
|
||||
if self.color_bottom.len() == 0 {
|
||||
continue;
|
||||
}
|
||||
if self.neighbor_bottom.len() > index {
|
||||
if let Some(_) = self.neighbor_bottom[index] {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
let quad = Quad {
|
||||
pos1: float_pos + Vector3 { x: -0.5 + x as f32, y: -0.5 + y as f32, z: -0.5 },
|
||||
pos4: float_pos + Vector3 { x: 0.5 + x as f32, y: -0.5 + y as f32, z: -0.5 },
|
||||
pos3: float_pos + Vector3 { x: 0.5 + x as f32, y: 0.5 + y as f32, z: -0.5 },
|
||||
pos2: float_pos + Vector3 { x: -0.5 + x as f32, y: 0.5 + y as f32, z: -0.5 },
|
||||
raster_pos: cgmath::Vector2 { x: x as u32, y: y as u32 },
|
||||
volume_index: 0
|
||||
};
|
||||
quads.push(quad);
|
||||
}
|
||||
}
|
||||
//top sides of the volumes, bottom side of the block
|
||||
for x in 0..self.size_x {
|
||||
for y in 0..self.size_y {
|
||||
let index = x * self.size_y + y;
|
||||
if self.color_top.len() == 0 {
|
||||
continue;
|
||||
}
|
||||
if self.neighbor_top.len() > index {
|
||||
if let Some(_) = self.neighbor_top[index] {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
let quad = Quad {
|
||||
pos4: float_pos + Vector3 { x: -0.5 + x as f32, y: -0.5 + y as f32, z: self.size_z as f32 - 0.5 },
|
||||
pos1: float_pos + Vector3 { x: 0.5 + x as f32, y: -0.5 + y as f32, z: self.size_z as f32 - 0.5 },
|
||||
pos2: float_pos + Vector3 { x: 0.5 + x as f32, y: 0.5 + y as f32, z: self.size_z as f32 - 0.5 },
|
||||
pos3: float_pos + Vector3 { x: -0.5 + x as f32, y: 0.5 + y as f32, z: self.size_z as f32 - 0.5 },
|
||||
raster_pos: cgmath::Vector2 { x: x as u32, y: y as u32 },
|
||||
volume_index: 0
|
||||
};
|
||||
quads.push(quad);
|
||||
}
|
||||
}
|
||||
|
||||
//front sides of the volumes, back side of the block
|
||||
for x in 0..self.size_x {
|
||||
for z in 0..self.size_z {
|
||||
let index = x * self.size_z + z;
|
||||
if self.color_front_rn.len() == 0 {
|
||||
continue;
|
||||
}
|
||||
if self.neighbor_front_rn.len() > index {
|
||||
if let Some(_) = self.neighbor_front_rn[index] {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
let quad = Quad {
|
||||
pos1: float_pos + Vector3 { x: -0.5 + x as f32, y: -0.5 + 0 as f32, z: z as f32 - 0.5 },
|
||||
pos4: float_pos + Vector3 { x: -0.5 + x as f32, y: -0.5 + 0 as f32, z: z as f32 + 0.5 },
|
||||
pos3: float_pos + Vector3 { x: 0.5 + x as f32, y: -0.5 + 0 as f32, z: z as f32 + 0.5 },
|
||||
pos2: float_pos + Vector3 { x: 0.5 + x as f32, y: -0.5 + 0 as f32, z: z as f32 - 0.5 },
|
||||
raster_pos: cgmath::Vector2 { x: x as u32, y: z as u32 },
|
||||
volume_index: 0
|
||||
};
|
||||
quads.push(quad);
|
||||
}
|
||||
}
|
||||
|
||||
//back sides of the volumes, front side of the block
|
||||
for x in 0..self.size_x {
|
||||
for z in 0..self.size_z {
|
||||
let index = x * self.size_z + z;
|
||||
if self.color_back_rn.len() == 0 {
|
||||
continue;
|
||||
}
|
||||
if self.neighbor_back_rn.len() > index {
|
||||
if let Some(_) = self.neighbor_back_rn[index] {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
let quad = Quad {
|
||||
pos4: float_pos + Vector3 { x: -0.5 + x as f32, y: -0.5 + self.size_y as f32, z: z as f32 - 0.5 },
|
||||
pos1: float_pos + Vector3 { x: -0.5 + x as f32, y: -0.5 + self.size_y as f32, z: z as f32 + 0.5 },
|
||||
pos2: float_pos + Vector3 { x: 0.5 + x as f32, y: -0.5 + self.size_y as f32, z: z as f32 + 0.5 },
|
||||
pos3: float_pos + Vector3 { x: 0.5 + x as f32, y: -0.5 + self.size_y as f32, z: z as f32 - 0.5 },
|
||||
raster_pos: cgmath::Vector2 { x: x as u32, y: z as u32 },
|
||||
volume_index: 0
|
||||
};
|
||||
quads.push(quad);
|
||||
}
|
||||
}
|
||||
quads
|
||||
}
|
||||
}
|
||||
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue