steffen/VoxelEngine2
1
0
Fork 0
Code Issues6 Pull requests Projects Releases Packages Wiki Activity Actions

first implementation, clamp seems to be off?

Browse source
This commit is contained in:
zomseffen 2025-03-06 18:11:44 +01:00
parent 7a58ba9733
commit b581364f5a
8 changed files with 157 additions and 132 deletions

BIN
shaders/compiled/frag_rt_quad.spv
View file

Binary file not shown.

65
shaders/rt_quad.frag
View file

@ -45,9 +45,12 @@ uvec4 unpack_color(uint val) {
return uvec4(val4, val3, val2, val1);
}
uint array_descr_offset = 6 + max_num_lights;
uint color_array_offset = 24 + 1;
uint sample_neighbor_from_scene_info(uint volume_start, uvec2 raster_pos, uint f) {
uint array_descr_start = volume_start + 6 + max_num_lights;
uint color_array_start = array_descr_start + 24;
uint array_descr_start = volume_start + array_descr_offset;
uint color_array_start = array_descr_start + color_array_offset;
uint top_color_size_u = scene_info.infos[array_descr_start];
uint top_color_size_v = scene_info.infos[array_descr_start + 1];
@ -116,8 +119,8 @@ uint sample_neighbor_from_scene_info(uint volume_start, vec2 raster_pos, uint f)
}
uvec4 sample_color_from_scene_info(uint volume_start, uvec2 raster_pos, uint f) {
uint array_descr_start = volume_start + 6 + max_num_lights;
uint color_array_start = array_descr_start + 24;
uint array_descr_start = volume_start + array_descr_offset;
uint color_array_start = array_descr_start + color_array_offset;
uint top_color_size_u = scene_info.infos[array_descr_start];
uint top_color_size_v = scene_info.infos[array_descr_start + 1];
@ -216,9 +219,10 @@ Tracing trace_ray(uint volume_start, vec3 starting_pos, vec3 start_direction, fl
uint cycle = start_cycle;
// setup volume info
uint volume_index = volume_start;
uint volume_pos_x = scene_info.infos[volume_index + 0];
uint volume_pos_y = scene_info.infos[volume_index + 1];
uint volume_pos_z = scene_info.infos[volume_index + 2];
float volume_scale = uintBitsToFloat(scene_info.infos[volume_index + array_descr_offset + color_array_offset - 1]);
float volume_pos_x = uintBitsToFloat(scene_info.infos[volume_index + 0]);
float volume_pos_y = uintBitsToFloat(scene_info.infos[volume_index + 1]);
float volume_pos_z = uintBitsToFloat(scene_info.infos[volume_index + 2]);
bool x_pos = direction.x > 0.0;
bool x_null = (direction.x == 0.0);
@ -249,9 +253,9 @@ Tracing trace_ray(uint volume_start, vec3 starting_pos, vec3 start_direction, fl
while (cycle < max_cycle) {
cycle ++;
float x_border = float(volume_pos_x + (scene_info.infos[volume_index + 3]) * uint(x_pos)) - 0.5;
float y_border = float(volume_pos_y + (scene_info.infos[volume_index + 4]) * uint(y_pos)) - 0.5;
float z_border = float(volume_pos_z + (scene_info.infos[volume_index + 5]) * uint(z_pos)) - 0.5;
float x_border = volume_pos_x + float((scene_info.infos[volume_index + 3]) * uint(x_pos)) * volume_scale - 0.5 * volume_scale;
float y_border = volume_pos_y + float((scene_info.infos[volume_index + 4]) * uint(y_pos)) * volume_scale - 0.5 * volume_scale;
float z_border = volume_pos_z + float((scene_info.infos[volume_index + 5]) * uint(z_pos)) * volume_scale - 0.5 * volume_scale;
bool needs_next_light = false;
@ -283,10 +287,10 @@ Tracing trace_ray(uint volume_start, vec3 starting_pos, vec3 start_direction, fl
hit_facing = uint(is_x_smallest) * (2 + uint(x_pos)) + uint(is_y_smallest) * (4 + uint(y_pos)) + uint(is_z_smallest && !z_pos);
float smallest_factor = min(min(x_factor, y_factor), z_factor); // maybe use multiplication instead?
vec3 intersection_pos = pos + smallest_factor * direction;
u = uint(is_x_smallest) * (uint(round(intersection_pos.y)) - volume_pos_y) +
uint(is_y_smallest || is_z_smallest) * (uint(round(intersection_pos.x)) - volume_pos_x);
v = uint(is_x_smallest || is_y_smallest) * (uint(round(intersection_pos.z)) - volume_pos_z) +
uint(is_z_smallest) * (uint(round(intersection_pos.y)) - volume_pos_y);
u = uint(is_x_smallest) * (uint(round((intersection_pos.y - volume_pos_y) / volume_scale))) +
uint(is_y_smallest || is_z_smallest) * (uint(round((intersection_pos.x - volume_pos_x) / volume_scale)));
v = uint(is_x_smallest || is_y_smallest) * (uint(round((intersection_pos.z - volume_pos_z) / volume_scale))) +
uint(is_z_smallest) * (uint(round((intersection_pos.y - volume_pos_y) / volume_scale)));
uint next_neighbor = sample_neighbor_from_scene_info(volume_index, uvec2(u, v), hit_facing);
uvec4 color_sample = sample_color_from_scene_info(volume_index, uvec2(u, v), hit_facing);
@ -295,9 +299,10 @@ Tracing trace_ray(uint volume_start, vec3 starting_pos, vec3 start_direction, fl
// not a color hit, so check neighbor
if (next_neighbor != 0) {
volume_index = next_neighbor;
volume_pos_x = scene_info.infos[volume_index + 0];
volume_pos_y = scene_info.infos[volume_index + 1];
volume_pos_z = scene_info.infos[volume_index + 2];
volume_scale = uintBitsToFloat(scene_info.infos[volume_index + array_descr_offset + color_array_offset - 1]);
volume_pos_x = uintBitsToFloat(scene_info.infos[volume_index + 0]);
volume_pos_y = uintBitsToFloat(scene_info.infos[volume_index + 1]);
volume_pos_z = uintBitsToFloat(scene_info.infos[volume_index + 2]);
} else {
// neighbor miss
end_color_transparent = uvec4(255, 0, 0, 255);
@ -311,9 +316,10 @@ Tracing trace_ray(uint volume_start, vec3 starting_pos, vec3 start_direction, fl
color_mul_transparent = result.color_mul;
volume_index = next_neighbor;
volume_pos_x = scene_info.infos[volume_index + 0];
volume_pos_y = scene_info.infos[volume_index + 1];
volume_pos_z = scene_info.infos[volume_index + 2];
volume_scale = uintBitsToFloat(scene_info.infos[volume_index + array_descr_offset + color_array_offset - 1]);
volume_pos_x = uintBitsToFloat(scene_info.infos[volume_index + 0]);
volume_pos_y = uintBitsToFloat(scene_info.infos[volume_index + 1]);
volume_pos_z = uintBitsToFloat(scene_info.infos[volume_index + 2]);
result.color_mul = result.color_mul * vec3(float(color_sample.x) / 255.0, float(color_sample.y) / 255.0, float(color_sample.z) / 255.0);
result.has_transparent_hit = true;
result.end_volume = volume_index;
@ -455,17 +461,18 @@ vec3 diffuse_tracing(uint volume_start, vec2 raster_pos, vec3 pos, uint f) {
}
vec3 clamp_to_volume(uint volume_start, vec3 position) {
uint volume_pos_x = scene_info.infos[volume_start + 0];
uint volume_pos_y = scene_info.infos[volume_start + 1];
uint volume_pos_z = scene_info.infos[volume_start + 2];
float volume_pos_x = uintBitsToFloat(scene_info.infos[volume_start + 0]);
float volume_pos_y = uintBitsToFloat(scene_info.infos[volume_start + 1]);
float volume_pos_z = uintBitsToFloat(scene_info.infos[volume_start + 2]);
float volume_scale = uintBitsToFloat(scene_info.infos[volume_start + array_descr_offset + color_array_offset - 1]);
float high_x_border = float(volume_pos_x + (scene_info.infos[volume_start + 3])) - 0.5;
float high_y_border = float(volume_pos_y + (scene_info.infos[volume_start + 4])) - 0.5;
float high_z_border = float(volume_pos_z + (scene_info.infos[volume_start + 5])) - 0.5;
float high_x_border = volume_pos_x + float(scene_info.infos[volume_start + 3]) * volume_scale - 0.5 * volume_scale;
float high_y_border = volume_pos_y + float(scene_info.infos[volume_start + 4]) * volume_scale - 0.5 * volume_scale;
float high_z_border = volume_pos_z + float(scene_info.infos[volume_start + 5]) * volume_scale - 0.5 * volume_scale;
float low_x_border = float(volume_pos_x) - 0.5;
float low_y_border = float(volume_pos_y) - 0.5;
float low_z_border = float(volume_pos_z) - 0.5;
float low_x_border = float(volume_pos_x) - 0.5 * volume_scale;
float low_y_border = float(volume_pos_y) - 0.5 * volume_scale;
float low_z_border = float(volume_pos_z) - 0.5 * volume_scale;
return vec3(min(max(position.x, low_x_border), high_x_border), min(max(position.y, low_y_border), high_y_border), min(max(position.z, low_z_border), high_z_border));
}

4
src/main.rs
View file

@ -224,8 +224,8 @@ impl App {
image::create_texture_image_view(&device, &mut data)?;
image::create_texture_sampler(&device, &mut data)?;
//let cur_pos = generators::generate_test_scene(&mut scene_handler, &mut data)?;
let cur_pos = generators::generate_test_scene2(&mut scene_handler, &mut data, 21, 21,1, 5)?;
let cur_pos = generators::generate_test_scene(&mut scene_handler, &mut data)?;
//let cur_pos = generators::generate_test_scene2(&mut scene_handler, &mut data, 21, 21,1, 5)?;
scene_handler.prepare_data(&instance, &device, &mut data)?;
buffer::create_uniform_buffers(&instance, &device, &mut data)?;

166
src/scene/empty_volume.rs
View file

@ -24,9 +24,8 @@ pub struct EmptyVolume {
pub size_y: usize,
pub size_z: usize,
pub tree_offset: Vector3<usize>,
pub tree_size: usize,
pub position: Vector3<usize>,
pub grid_position: Vector3<usize>,
pub real_position: Vector3<f32>,
pub color_left: Vec<Vector3<u8>>,
pub color_right: Vec<Vector3<u8>>,
@ -48,13 +47,21 @@ pub struct EmptyVolume {
pub neighbor_bottom: Vec<Option<Rc<RefCell<Self>>>>,
pub neighbor_back: Vec<Option<Rc<RefCell<Self>>>>,
pub neighbor_front: Vec<Option<Rc<RefCell<Self>>>>,
pub scale: f32,
}
impl EmptyVolume {
pub fn contains(&self, pos: &Vector3<usize>) -> bool {
self.position[0] + self.size_x > pos[0] && pos[0] >= self.position[0] &&
self.position[1] + self.size_y > pos[1] && pos[1] >= self.position[1] &&
self.position[2] + self.size_z > pos[2] && pos[2] >= self.position[2]
pub fn contains_grid_pos(&self, pos: &Vector3<usize>) -> bool {
self.grid_position[0] + self.size_x > pos[0] && pos[0] >= self.grid_position[0] &&
self.grid_position[1] + self.size_y > pos[1] && pos[1] >= self.grid_position[1] &&
self.grid_position[2] + self.size_z > pos[2] && pos[2] >= self.grid_position[2]
}
pub fn contains_real_pos(&self, pos: &Vector3<f32>) -> bool {
self.real_position[0] + self.size_x as f32 > pos[0] && pos[0] >= self.real_position[0] &&
self.real_position[1] + self.size_y as f32 > pos[1] && pos[1] >= self.real_position[1] &&
self.real_position[2] + self.size_z as f32 > pos[2] && pos[2] >= self.real_position[2]
}
fn check_transparent(cube_result: Option<Cube>, transparent_color: &Vector3<f32>, transparent_roughness: &u8) -> bool {
@ -65,11 +72,11 @@ impl EmptyVolume {
}
// MARK: From Oct Tree
pub fn from_oct_tree(tree: &Rc<RefCell<OctTree<Cube>>>, tree_offset: Vector3<usize>) -> (Vec<Rc<RefCell<EmptyVolume>>>, OctTree<Rc<RefCell<EmptyVolume>>>) {
pub fn from_oct_tree(tree: &Rc<RefCell<OctTree<Cube>>>, tree_pos: Vector3<f32>) -> (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.borrow().size).unwrap();
let mut neighbors: OctTree<Rc<RefCell<EmptyVolume>>> = OctTree::create(tree.borrow().size, tree.borrow().scale).unwrap();
let start_time = Instant::now();
// iterate over all block positions in the oct tree
let mut check_its = 0;
@ -94,9 +101,9 @@ impl EmptyVolume {
//if not check that it is not already inside of a volume
let mut contained = false;
for volume in &volumes {
if volume.borrow().contains(&Vector3{x: x_index, y: y_index, z: z_index}) {
if volume.borrow().contains_grid_pos(&Vector3{x: x_index, y: y_index, z: z_index}) {
contained = true;
z_index = volume.borrow().size_z + volume.borrow().position.z;
z_index = volume.borrow().size_z + volume.borrow().grid_position.z;
break;
}
}
@ -276,9 +283,8 @@ impl EmptyVolume {
size_x: x_size + 1,
size_y: y_size + 1,
size_z: z_size + 1,
tree_offset,
tree_size: tree.borrow().size,
position: Vector3{x: x_index, y: y_index, z: z_index},
grid_position: Vector3{x: x_index, y: y_index, z: z_index},
real_position: tree_pos + Vector3{x: x_index as f32 * tree.borrow().scale, y: y_index as f32 * tree.borrow().scale, z: z_index as f32 * tree.borrow().scale},
color_left: vec![],
color_right: vec![],
color_top: vec![],
@ -297,6 +303,7 @@ impl EmptyVolume {
neighbor_bottom: vec![],
neighbor_back: vec![],
neighbor_front: vec![],
scale: tree.borrow().scale,
};
println!("adding neighbor references");
// MARK: fill in info in the neighbor octtree
@ -304,7 +311,7 @@ impl EmptyVolume {
for x in 0..x_size+1 {
for y in 0..y_size+1 {
for z in 0..z_size+1 {
neighbors.set_element(reference.clone(), reference.borrow().position.x + x, reference.borrow().position.y + y, reference.borrow().position.z + z);
neighbors.set_element(reference.clone(), reference.borrow().grid_position.x + x, reference.borrow().grid_position.y + y, reference.borrow().grid_position.z + z);
// 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)
@ -314,39 +321,39 @@ impl EmptyVolume {
}
println!("add the border information for color and roughness");
let x_min_pos;
if reference.borrow().position.x == 0 {
if reference.borrow().grid_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;
x_min_pos = reference.borrow().grid_position.x -1;
}
let y_min_pos;
if reference.borrow().position.y == 0 {
if reference.borrow().grid_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;
y_min_pos = reference.borrow().grid_position.y -1;
}
let z_min_pos;
if reference.borrow().position.z == 0 {
if reference.borrow().grid_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;
z_min_pos = reference.borrow().grid_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;
let x_max_pos = reference.borrow().grid_position.x + reference.borrow().size_x;
let y_max_pos = reference.borrow().grid_position.y + reference.borrow().size_y;
let z_max_pos = reference.borrow().grid_position.z + reference.borrow().size_z;
// MARK: 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.borrow().get_element(reference.borrow().position.x + x, reference.borrow().position.y + y, z_min_pos) {
if let Some(c) = tree.borrow().get_element(reference.borrow().grid_position.x + x, reference.borrow().grid_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);
@ -372,7 +379,7 @@ impl EmptyVolume {
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.borrow().get_element(reference.borrow().position.x + x, reference.borrow().position.y + y, z_max_pos) {
if let Some(c) = tree.borrow().get_element(reference.borrow().grid_position.x + x, reference.borrow().grid_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);
@ -399,7 +406,7 @@ impl EmptyVolume {
let mut back_elements_num = 0;
for x in 0..x_size+1 {
for z in 0..z_size+1 {
if let Some(c) = tree.borrow().get_element(reference.borrow().position.x + x, y_max_pos, reference.borrow().position.z + z) {
if let Some(c) = tree.borrow().get_element(reference.borrow().grid_position.x + x, y_max_pos, reference.borrow().grid_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);
@ -426,7 +433,7 @@ impl EmptyVolume {
let mut front_elements_num = 0;
for x in 0..x_size+1 {
for z in 0..z_size+1 {
if let Some(c) = tree.borrow().get_element(reference.borrow().position.x + x, y_min_pos, reference.borrow().position.z + z) {
if let Some(c) = tree.borrow().get_element(reference.borrow().grid_position.x + x, y_min_pos, reference.borrow().grid_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);
@ -453,7 +460,7 @@ impl EmptyVolume {
let mut left_elements_num = 0;
for y in 0..y_size+1 {
for z in 0..z_size+1 {
if let Some(c) = tree.borrow().get_element(x_min_pos, reference.borrow().position.y + y, reference.borrow().position.z + z) {
if let Some(c) = tree.borrow().get_element(x_min_pos, reference.borrow().grid_position.y + y, reference.borrow().grid_position.z + z) {
left_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};
left_colors.push(u8_color);
@ -480,7 +487,7 @@ impl EmptyVolume {
let mut right_elements_num = 0;
for y in 0..y_size+1 {
for z in 0..z_size+1 {
if let Some(c) = tree.borrow().get_element(x_max_pos, reference.borrow().position.y + y, reference.borrow().position.z + z) {
if let Some(c) = tree.borrow().get_element(x_max_pos, reference.borrow().grid_position.y + y, reference.borrow().grid_position.z + z) {
right_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};
right_colors.push(u8_color);
@ -516,39 +523,39 @@ impl EmptyVolume {
// MARK: Neighbor Linkage
for reference in volumes.iter_mut() {
let x_min_pos;
if reference.borrow().position.x == 0 {
if reference.borrow().grid_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;
x_min_pos = reference.borrow().grid_position.x - 1;
}
let y_min_pos;
if reference.borrow().position.y == 0 {
if reference.borrow().grid_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;
y_min_pos = reference.borrow().grid_position.y - 1;
}
let z_min_pos;
if reference.borrow().position.z == 0 {
if reference.borrow().grid_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;
z_min_pos = reference.borrow().grid_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;
let x_max_pos = reference.borrow().grid_position.x + reference.borrow().size_x;
let y_max_pos = reference.borrow().grid_position.y + reference.borrow().size_y;
let z_max_pos = reference.borrow().grid_position.z + reference.borrow().size_z;
// MARK: bottom face of the volume
let mut bottom_neighbors = vec![];
let mut bottom_elements_num = 0;
let mut all_same = true;
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) {
if let Some(c) = neighbors.get_element(reference.borrow().grid_position.x + x, reference.borrow().grid_position.y + y, z_min_pos) {
bottom_elements_num += 1;
bottom_neighbors.push(Some(c.clone()));
all_same = all_same && (bottom_neighbors[0] == Some(c));
@ -576,7 +583,7 @@ impl EmptyVolume {
let mut all_same = true;
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) {
if let Some(c) = neighbors.get_element(reference.borrow().grid_position.x + x, reference.borrow().grid_position.y + y, z_max_pos) {
top_elements_num += 1;
top_neighbors.push(Some(c.clone()));
all_same = all_same && (top_neighbors[0] == Some(c));
@ -605,7 +612,7 @@ impl EmptyVolume {
let mut all_same = true;
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) {
if let Some(c) = neighbors.get_element(reference.borrow().grid_position.x + x, y_max_pos, reference.borrow().grid_position.z + z) {
back_elements_num += 1;
back_neighbors.push(Some(c.clone()));
all_same = all_same && (back_neighbors[0] == Some(c));
@ -634,7 +641,7 @@ impl EmptyVolume {
let mut all_same = true;
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) {
if let Some(c) = neighbors.get_element(reference.borrow().grid_position.x + x, y_min_pos, reference.borrow().grid_position.z + z) {
front_elements_num += 1;
front_neighbors.push(Some(c.clone()));
all_same = all_same && (front_neighbors[0] == Some(c));
@ -663,7 +670,7 @@ impl EmptyVolume {
let mut all_same = true;
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) {
if let Some(c) = neighbors.get_element(x_min_pos, reference.borrow().grid_position.y + y, reference.borrow().grid_position.z + z) {
left_elements_num += 1;
left_neighbors.push(Some(c.clone()));
all_same = all_same && (left_neighbors[0] == Some(c));
@ -692,7 +699,7 @@ impl EmptyVolume {
let mut all_same = true;
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) {
if let Some(c) = neighbors.get_element(x_max_pos, reference.borrow().grid_position.y + y, reference.borrow().grid_position.z + z) {
right_elements_num += 1;
right_neighbors.push(Some(c.clone()));
all_same = all_same && (right_neighbors[0] == Some(c));
@ -761,7 +768,7 @@ impl EmptyVolume {
// MARK: To Quads
pub fn to_quads(&self) -> Vec<Quad> {
let mut quads = vec![];
let float_pos = Vector3 {x: (self.tree_offset.x * self.tree_size + self.position.x) as f32, y: (self.tree_offset.y * self.tree_size + self.position.y) as f32, z: (self.tree_offset.z * self.tree_size + self.position.z) as f32};
let float_pos = self.real_position;
//bottom sides of the volumes, top side of the block
let mut done = vec![];
for x in 0..self.size_x {
@ -785,10 +792,10 @@ impl EmptyVolume {
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 + size_1) as f32, y: -0.5 + y as f32, z: -0.5 },
pos3: float_pos + Vector3 { x: 0.5 + (x + size_1) as f32, y: 0.5 + (y + size_2) as f32, z: -0.5 },
pos2: float_pos + Vector3 { x: -0.5 + x as f32, y: 0.5 + (y + size_2) as f32, z: -0.5 },
pos1: float_pos + Vector3 { x: -0.5 + x as f32, y: -0.5 + y as f32, z: -0.5 } * self.scale,
pos4: float_pos + Vector3 { x: 0.5 + (x + size_1) as f32, y: -0.5 + y as f32, z: -0.5 } * self.scale,
pos3: float_pos + Vector3 { x: 0.5 + (x + size_1) as f32, y: 0.5 + (y + size_2) as f32, z: -0.5 } * self.scale,
pos2: float_pos + Vector3 { x: -0.5 + x as f32, y: 0.5 + (y + size_2) as f32, z: -0.5 } * self.scale,
raster_pos: cgmath::Vector2 { x: x as u32, y: y as u32 },
size: cgmath::Vector2 { x: (size_1 + 1) as u32, y: (size_2 + 1) as u32 },
volume_index: self.memory_start as u32,
@ -818,10 +825,10 @@ impl EmptyVolume {
}
}
let quad = Quad {
pos1: float_pos + Vector3 { x: -0.5 + x as f32, y: -0.5 + y as f32, z: self.size_z as f32 - 0.5 },
pos4: float_pos + Vector3 { x: 0.5 + (x + size_1) as f32, y: -0.5 + y as f32, z: self.size_z as f32 - 0.5 },
pos3: float_pos + Vector3 { x: 0.5 + (x + size_1) as f32, y: 0.5 + (y + size_2) as f32, z: self.size_z as f32 - 0.5 },
pos2: float_pos + Vector3 { x: -0.5 + x as f32, y: 0.5 + (y + size_2) 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 } * self.scale,
pos4: float_pos + Vector3 { x: 0.5 + (x + size_1) as f32, y: -0.5 + y as f32, z: self.size_z as f32 - 0.5 } * self.scale,
pos3: float_pos + Vector3 { x: 0.5 + (x + size_1) as f32, y: 0.5 + (y + size_2) as f32, z: self.size_z as f32 - 0.5 } * self.scale,
pos2: float_pos + Vector3 { x: -0.5 + x as f32, y: 0.5 + (y + size_2) as f32, z: self.size_z as f32 - 0.5 } * self.scale,
raster_pos: cgmath::Vector2 { x: x as u32, y: y as u32 },
size: cgmath::Vector2 { x: (size_1 + 1) as u32, y: (size_2 + 1) as u32 },
volume_index: self.memory_start as u32,
@ -852,10 +859,10 @@ impl EmptyVolume {
}
}
let quad = Quad {
pos2: float_pos + Vector3 { x: -0.5 + x as f32, y: -0.5 + 0 as f32, z: z as f32 - 0.5 },
pos1: float_pos + Vector3 { x: -0.5 + x as f32, y: -0.5 + 0 as f32, z: (z + size_2) as f32 + 0.5 },
pos4: float_pos + Vector3 { x: 0.5 + (x + size_1) as f32, y: -0.5 + 0 as f32, z: (z + size_2) as f32 + 0.5 },
pos3: float_pos + Vector3 { x: 0.5 + (x + size_1) 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 } * self.scale,
pos1: float_pos + Vector3 { x: -0.5 + x as f32, y: -0.5 + 0 as f32, z: (z + size_2) as f32 + 0.5 } * self.scale,
pos4: float_pos + Vector3 { x: 0.5 + (x + size_1) as f32, y: -0.5 + 0 as f32, z: (z + size_2) as f32 + 0.5 } * self.scale,
pos3: float_pos + Vector3 { x: 0.5 + (x + size_1) as f32, y: -0.5 + 0 as f32, z: z as f32 - 0.5 } * self.scale,
raster_pos: cgmath::Vector2 { x: x as u32, y: z as u32 },
size: cgmath::Vector2 { x: (size_1 + 1) as u32, y: (size_2 + 1) as u32 },
volume_index: self.memory_start as u32,
@ -886,10 +893,10 @@ impl EmptyVolume {
}
}
let quad = Quad {
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 + size_2) as f32 + 0.5 },
pos3: float_pos + Vector3 { x: 0.5 + (x + size_1) as f32, y: -0.5 + self.size_y as f32, z: (z + size_2) as f32 + 0.5 },
pos4: float_pos + Vector3 { x: 0.5 + (x + size_1) 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 } * self.scale,
pos2: float_pos + Vector3 { x: -0.5 + x as f32, y: -0.5 + self.size_y as f32, z: (z + size_2) as f32 + 0.5 } * self.scale,
pos3: float_pos + Vector3 { x: 0.5 + (x + size_1) as f32, y: -0.5 + self.size_y as f32, z: (z + size_2) as f32 + 0.5 } * self.scale,
pos4: float_pos + Vector3 { x: 0.5 + (x + size_1) as f32, y: -0.5 + self.size_y as f32, z: z as f32 - 0.5 } * self.scale,
raster_pos: cgmath::Vector2 { x: x as u32, y: z as u32 },
size: cgmath::Vector2 { x: (size_1 + 1) as u32, y: (size_2 + 1) as u32 },
volume_index: self.memory_start as u32,
@ -920,10 +927,10 @@ impl EmptyVolume {
}
}
let quad = Quad {
pos1: float_pos + Vector3 { x: -0.5 + 0.0 as f32, y: y as f32 - 0.5, z: z as f32 - 0.5 },
pos2: float_pos + Vector3 { x: -0.5 + 0.0 as f32, y: y as f32 - 0.5, z: (z + size_2) as f32 + 0.5 },
pos3: float_pos + Vector3 { x: -0.5 + 0.0 as f32, y: (y + size_1) as f32 + 0.5, z: (z + size_2) as f32 + 0.5 },
pos4: float_pos + Vector3 { x: -0.5 + 0.0 as f32, y: (y + size_1) as f32 + 0.5, z: z as f32 - 0.5 },
pos1: float_pos + Vector3 { x: -0.5 + 0.0 as f32, y: y as f32 - 0.5, z: z as f32 - 0.5 } * self.scale,
pos2: float_pos + Vector3 { x: -0.5 + 0.0 as f32, y: y as f32 - 0.5, z: (z + size_2) as f32 + 0.5 } * self.scale,
pos3: float_pos + Vector3 { x: -0.5 + 0.0 as f32, y: (y + size_1) as f32 + 0.5, z: (z + size_2) as f32 + 0.5 } * self.scale,
pos4: float_pos + Vector3 { x: -0.5 + 0.0 as f32, y: (y + size_1) as f32 + 0.5, z: z as f32 - 0.5 } * self.scale,
raster_pos: cgmath::Vector2 { x: y as u32, y: z as u32 },
size: cgmath::Vector2 { x: (size_1 + 1) as u32, y: (size_2 + 1) as u32 },
volume_index: self.memory_start as u32,
@ -954,10 +961,10 @@ impl EmptyVolume {
}
}
let quad = Quad {
pos2: float_pos + Vector3 { x: -0.5 + self.size_x as f32, y: y as f32 - 0.5, z: z as f32 - 0.5 },
pos1: float_pos + Vector3 { x: -0.5 + self.size_x as f32, y: y as f32 - 0.5, z: (z + size_2) as f32 + 0.5 },
pos4: float_pos + Vector3 { x: -0.5 + self.size_x as f32, y: (y + size_1) as f32 + 0.5, z: (z + size_2) as f32 + 0.5 },
pos3: float_pos + Vector3 { x: -0.5 + self.size_x as f32, y: (y + size_1) as f32 + 0.5, z: z as f32 - 0.5 },
pos2: float_pos + Vector3 { x: -0.5 + self.size_x as f32, y: y as f32 - 0.5, z: z as f32 - 0.5 } * self.scale,
pos1: float_pos + Vector3 { x: -0.5 + self.size_x as f32, y: y as f32 - 0.5, z: (z + size_2) as f32 + 0.5 } * self.scale,
pos4: float_pos + Vector3 { x: -0.5 + self.size_x as f32, y: (y + size_1) as f32 + 0.5, z: (z + size_2) as f32 + 0.5 } * self.scale,
pos3: float_pos + Vector3 { x: -0.5 + self.size_x as f32, y: (y + size_1) as f32 + 0.5, z: z as f32 - 0.5 } * self.scale,
raster_pos: cgmath::Vector2 { x: y as u32, y: z as u32 },
size: cgmath::Vector2 { x: (size_1 + 1) as u32, y: (size_2 + 1) as u32 },
volume_index: self.memory_start as u32,
@ -972,7 +979,7 @@ impl EmptyVolume {
pub fn select_lights(&self, lights: LightsIter, light_number: u32, min_light_weight: f32) -> Vec<u32> {
let mut weighted_indices = vec![];
for light in lights {
let weight = light.borrow().weighted_distance(self.position + self.tree_offset * self.tree_size, Vector3{x: self.size_x, y: self.size_y, z: self.size_z});
let weight = light.borrow().weighted_distance(self.real_position, Vector3{x: self.size_x as f32, y: self.size_y as f32, z: self.size_z as f32} * self.scale);
if weight >= min_light_weight {
weighted_indices.push((weight, light.borrow().get_memory_start()));
}
@ -1057,8 +1064,8 @@ impl EmptyVolume {
let mask = Vector3 {x: 1, y: 1, z: 1} - (step_one + step_two);
let negated_mask = (step_one + step_two);
let volume_start_first = negated_mask.mul_element_wise(volume.borrow().position) + first_pos.mul_element_wise(mask);
let volume_start_second = negated_mask.mul_element_wise(volume.borrow().position) + second_pos.mul_element_wise(mask);
let volume_start_first = negated_mask.mul_element_wise(volume.borrow().grid_position) + first_pos.mul_element_wise(mask);
let volume_start_second = negated_mask.mul_element_wise(volume.borrow().grid_position) + second_pos.mul_element_wise(mask);
let size_u;
let size_v;
@ -1178,6 +1185,7 @@ impl Memorizable for EmptyVolume {
mem_size += data.num_lights_per_volume; // light references
mem_size += 12; //color/roughness buffer sizes, 2 values each
mem_size += 12; //neighbor buffer sizes, 2 values each
mem_size += 1; //scale of the volume, 1 float
// this covers full color and roughness
mem_size += (self.color_top.len() as u32).max(1);
@ -1200,11 +1208,11 @@ impl Memorizable for EmptyVolume {
fn insert_into_memory(&self, mut v: Vec<u32>, data: &AppData, scene: &Scene) -> Vec<u32> {
let mut mem_index = self.memory_start;
//pos
v[mem_index] = (self.tree_offset.x * self.tree_size + self.position.x) as u32;
v[mem_index] = u32::from_ne_bytes(self.real_position.x.to_ne_bytes());
mem_index += 1;
v[mem_index] = (self.tree_offset.y * self.tree_size + self.position.y) as u32;
v[mem_index] = u32::from_ne_bytes(self.real_position.y.to_ne_bytes());
mem_index += 1;
v[mem_index] = (self.tree_offset.z * self.tree_size + self.position.z) as u32;
v[mem_index] = u32::from_ne_bytes(self.real_position.z.to_ne_bytes());
mem_index += 1;
//max sizes
v[mem_index] = self.size_x as u32;
@ -1328,6 +1336,10 @@ impl Memorizable for EmptyVolume {
}
mem_index += 2;
// scale factor
v[mem_index] = u32::from_ne_bytes(self.scale.to_ne_bytes());
mem_index += 1;
//color and roughness
//check which endian should be used in conjunction of the graphics card (might already be handled by vulkan)
if self.color_top.len() > 0 {
@ -1525,7 +1537,7 @@ impl Memorizable for EmptyVolume {
impl PartialEq for EmptyVolume {
fn eq(&self, other: &Self) -> bool {
self.position == other.position
self.grid_position == other.grid_position
&& self.size_x == other.size_x
&& self.size_y == other.size_y
&& self.size_z == other.size_z

22
src/scene/generators.rs
View file

@ -22,8 +22,10 @@ pub fn generate_test_scene(scene: &mut Scene, data: &mut AppData) -> Result<(Poi
let mut rng = rand::thread_rng();
let grid_size = CHUNK_SIZE as i32;
let mut oct_tree1: OctTree<Cube> = OctTree::create(CHUNK_SIZE)?;
let mut oct_tree2: OctTree<Cube> = OctTree::create(CHUNK_SIZE)?;
let scale = 1.0;
let mut oct_tree1: OctTree<Cube> = OctTree::create(CHUNK_SIZE, scale)?;
let mut oct_tree2: OctTree<Cube> = OctTree::create(CHUNK_SIZE, scale)?;
for x_index in 0..grid_size {
for y_index in 0..grid_size {
@ -89,24 +91,24 @@ pub fn generate_test_scene(scene: &mut Scene, data: &mut AppData) -> Result<(Poi
};
oct_tree2.set_cube(cube.clone());
scene.point_lights.push(Rc::new(RefCell::new(PointLight { pos: vec3(11.0 + grid_size as f32, 11.0 + grid_size as f32, 11.0), color: vec3(1.0, 1.0, 1.0), memory_start: 0 })));
scene.point_lights.push(Rc::new(RefCell::new(PointLight { pos: vec3(9.0 + grid_size as f32, 9.0 + grid_size as f32, 11.0), color: vec3(0.5, 0.5, 0.5), memory_start: 0 })));
scene.point_lights.push(Rc::new(RefCell::new(PointLight { pos: vec3(11.0 + grid_size as f32, 11.0 + grid_size as f32, 11.0) * scale, color: vec3(1.0, 1.0, 1.0), memory_start: 0 })));
scene.point_lights.push(Rc::new(RefCell::new(PointLight { pos: vec3(9.0 + grid_size as f32, 9.0 + grid_size as f32, 11.0) * scale, color: vec3(0.5, 0.5, 0.5), memory_start: 0 })));
scene.directional_lights.push(Rc::new(RefCell::new(DirectionalLight { direction: vec3(1.0, 1.0, -1.0), color: vec3(0.1, 0.1, 0.1), memory_start: 0 })));
let cube = Cuboid {
pos: vec3(11.0 + grid_size as f32, 11.0 + grid_size as f32, 11.0),
pos: vec3(11.0 + grid_size as f32, 11.0 + grid_size as f32, 11.0) * scale,
color: vec3(1.0, 1.0, 1.0),
tex_coord: vec2(0.0, 0.0),
size: Vector3 {x: 0.5, y: 0.5, z: 0.5}
size: Vector3 {x: 0.5, y: 0.5, z: 0.5} * scale
};
let index = scene.sized_vertices.len();
cube.draw(&data.topology, index, scene);
let cube = Cuboid {
pos: vec3(9.0 + grid_size as f32, 9.0 + grid_size as f32, 11.0),
pos: vec3(9.0 + grid_size as f32, 9.0 + grid_size as f32, 11.0) * scale,
color: vec3(1.0, 1.0, 1.0),
tex_coord: vec2(0.0, 0.0),
size: Vector3 {x: 0.5, y: 0.5, z: 0.5}
size: Vector3 {x: 0.5, y: 0.5, z: 0.5} * scale
};
let index = scene.sized_vertices.len();
cube.draw(&data.topology, index, scene);
@ -122,6 +124,8 @@ pub fn generate_test_scene(scene: &mut Scene, data: &mut AppData) -> Result<(Poi
pub fn generate_test_scene2(scene: &mut Scene, data: &mut AppData, chunk_num_x: usize, chunk_num_y: usize, chunk_num_z: usize, num_gaussians: usize) -> Result<(Point3<f32>)> {
let mut rng = rand::thread_rng();
let scale = 1.0;
let grid_size = CHUNK_SIZE as i32;
let max_x = chunk_num_x * grid_size as usize;
@ -152,7 +156,7 @@ pub fn generate_test_scene2(scene: &mut Scene, data: &mut AppData, chunk_num_x:
for y in 0..chunk_num_y {
oct_trees[z].push(vec![]);
for x in 0..chunk_num_x {
oct_trees[z][y].push(Rc::new(RefCell::new(OctTree::<Cube>::create(CHUNK_SIZE)?)));
oct_trees[z][y].push(Rc::new(RefCell::new(OctTree::<Cube>::create(CHUNK_SIZE, scale)?)));
}
}
}

8
src/scene/light.rs
View file

@ -13,7 +13,7 @@ pub enum LightType {
pub trait Light {
fn get_light_type(&self) -> LightType;
fn weighted_distance(&self, pos: Vector3<usize>, size: Vector3<usize>) -> f32;
fn weighted_distance(&self, pos: Vector3<f32>, size: Vector3<f32>) -> f32;
}
pub trait LightSource: Light + Memorizable {}
@ -58,9 +58,9 @@ impl Light for PointLight {
LightType::POINT
}
fn weighted_distance(&self, pos: Vector3<usize>, size: Vector3<usize>) -> f32 {
fn weighted_distance(&self, pos: Vector3<f32>, size: Vector3<f32>) -> f32 {
let low_end = vertex::Vec3{x: pos.x as f32, y: pos.y as f32, z: pos.z as f32};
let high_end = vertex::Vec3{x: (pos.x + size.x) as f32, y: (pos.y + size.y) as f32, z: (pos.z + size.z) as f32};
let high_end = pos + size;
let distance;
if low_end.x <= self.pos.x && self.pos.x <= high_end.x && low_end.y <= self.pos.y && self.pos.y <= high_end.y && low_end.z <= self.pos.z && self.pos.z <= high_end.z {
let diff_low = self.pos - low_end;
@ -152,7 +152,7 @@ impl Light for DirectionalLight {
LightType::DIRECTION
}
fn weighted_distance(&self, pos: Vector3<usize>, size: Vector3<usize>) -> f32 {
fn weighted_distance(&self, pos: Vector3<f32>, size: Vector3<f32>) -> f32 {
let light_intensity = self.color.magnitude();
light_intensity

2
src/scene/mod.rs
View file

@ -83,7 +83,7 @@ impl Scene {
for oct_tree in oct_tree_line_y {
let mut new_volumes: Vec<Rc<RefCell<EmptyVolume>>>;
let new_neighbors;
(new_volumes, new_neighbors) = EmptyVolume::from_oct_tree(oct_tree, Vector3 { x: x_index, y: y_index, z: z_index });
(new_volumes, new_neighbors) = EmptyVolume::from_oct_tree(oct_tree, Vector3 { x: (x_index * CHUNK_SIZE) as f32 * oct_tree.borrow().scale, y: (y_index * CHUNK_SIZE) as f32 * oct_tree.borrow().scale, z: (z_index * CHUNK_SIZE) as f32 * oct_tree.borrow().scale });
empty_volumes.append(&mut new_volumes);
neighbor_trees[z_index][y_index].push(Rc::new(new_neighbors));

22
src/scene/oct_tree.rs
View file

@ -27,6 +27,7 @@ pub struct OctTree<T> {
pub blocks: Vec<Option<T>>,
pub size: usize,
pub scale: f32,
}
#[warn(non_snake_case)]
@ -43,7 +44,7 @@ impl OctTree<Cube> {
}
impl<T: Clone> OctTree<T> {
pub fn create(size: usize) -> Result<Self> {
pub fn create(size: usize, scale: f32) -> Result<Self> {
let mut blocks: Vec<Option<T>> = vec![];
if size == MIN_CHUNK_SIZE {
for _ in 0..MIN_CHUNK_SIZE {
@ -68,6 +69,7 @@ impl<T: Clone> OctTree<T> {
blocks: blocks,
size,
scale,
})
}
@ -89,7 +91,7 @@ impl<T: Clone> OctTree<T> {
child.borrow_mut().set_element_internal(element, x - mid_point, y - mid_point, z - mid_point);
},
None => {
let mut child = OctTree::create(self.size / 2).unwrap();
let mut child = OctTree::create(self.size / 2, self.scale).unwrap();
child.set_element_internal(element, x - mid_point, y - mid_point, z - mid_point);
self.child_XYZ = Some(Rc::new(RefCell::new(child)));
}
@ -101,7 +103,7 @@ impl<T: Clone> OctTree<T> {
child.borrow_mut().set_element_internal(element, x - mid_point, y - mid_point, z);
},
None => {
let mut child = OctTree::create(self.size / 2).unwrap();
let mut child = OctTree::create(self.size / 2, self.scale).unwrap();
child.set_element_internal(element, x - mid_point, y - mid_point, z);
self.child_XYz = Some(Rc::new(RefCell::new(child)));
}
@ -115,7 +117,7 @@ impl<T: Clone> OctTree<T> {
child.borrow_mut().set_element_internal(element, x - mid_point, y, z - mid_point);
},
None => {
let mut child = OctTree::create(self.size / 2).unwrap();
let mut child = OctTree::create(self.size / 2, self.scale).unwrap();
child.set_element_internal(element, x - mid_point, y, z - mid_point);
self.child_XyZ = Some(Rc::new(RefCell::new(child)));
}
@ -127,7 +129,7 @@ impl<T: Clone> OctTree<T> {
child.borrow_mut().set_element_internal(element, x - mid_point, y, z);
},
None => {
let mut child = OctTree::create(self.size / 2).unwrap();
let mut child = OctTree::create(self.size / 2, self.scale).unwrap();
child.set_element_internal(element, x - mid_point, y, z);
self.child_Xyz = Some(Rc::new(RefCell::new(child)));
}
@ -143,7 +145,7 @@ impl<T: Clone> OctTree<T> {
child.borrow_mut().set_element_internal(element, x, y - mid_point, z - mid_point);
},
None => {
let mut child = OctTree::create(self.size / 2).unwrap();
let mut child = OctTree::create(self.size / 2, self.scale).unwrap();
child.set_element_internal(element, x, y - mid_point, z - mid_point);
self.child_xYZ = Some(Rc::new(RefCell::new(child)));
}
@ -155,7 +157,7 @@ impl<T: Clone> OctTree<T> {
child.borrow_mut().set_element_internal(element, x, y - mid_point, z);
},
None => {
let mut child = OctTree::create(self.size / 2).unwrap();
let mut child = OctTree::create(self.size / 2, self.scale).unwrap();
child.set_element_internal(element, x, y - mid_point, z);
self.child_xYz = Some(Rc::new(RefCell::new(child)));
}
@ -169,7 +171,7 @@ impl<T: Clone> OctTree<T> {
child.borrow_mut().set_element_internal(element, x, y, z - mid_point);
},
None => {
let mut child = OctTree::create(self.size / 2).unwrap();
let mut child = OctTree::create(self.size / 2, self.scale).unwrap();
child.set_element_internal(element, x, y, z - mid_point);
self.child_xyZ = Some(Rc::new(RefCell::new(child)));
}
@ -181,7 +183,7 @@ impl<T: Clone> OctTree<T> {
child.borrow_mut().set_element_internal(element, x, y, z);
},
None => {
let mut child = OctTree::create(self.size / 2).unwrap();
let mut child = OctTree::create(self.size / 2, self.scale).unwrap();
child.set_element_internal(element, x, y, z);
self.child_xyz = Some(Rc::new(RefCell::new(child)));
}
@ -600,7 +602,7 @@ mod test {
#[test]
fn test_oct_tree(){
let mut test_tree: OctTree<Cube> = OctTree::create(512).unwrap();
let mut test_tree: OctTree<Cube> = OctTree::create(512, 1.0).unwrap();
let test_cube = Cube{color: Vector3 { x: 1.0, y: 0.0, z: 0.0 }, pos: Vector3 { x: 5.0, y: 2.0, z: 10.0 }, tex_coord: Vector2{x: 0.0, y: 0.0}, transparent: false, roughness: 128};
test_tree.set_cube(test_cube.clone());