first implementation, clamp seems to be off?
This commit is contained in:
zomseffen
parent
7a58ba9733
commit
b581364f5a
8 changed files with 157 additions and 132 deletions
src/scene
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue