refactor scene.rs into multiple files

src/scene/mod.rs

@@ -0,0 +1,180 @@
+mod oct_tree;
+mod empty_volume;
+
+use anyhow::Ok;
+use vulkanalia::prelude::v1_0::*;
+use anyhow::Result;
+
+use cgmath::{vec2, vec3};
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use crate::app_data::AppData;
+use crate::buffer;
+use crate::vertex;
+use crate::primitives::cube::Cube;
+use crate::primitives::drawable::Drawable;
+use crate::scene::oct_tree::{OctTree, OctTreeIter, CHUNK_SIZE};
+use crate::scene::empty_volume::EmptyVolume;
+
+extern crate rand;
+use rand::Rng;
+
+#[repr(C)]
+#[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,
+
+    pub index_buffer_cube: vk::Buffer,
+    pub index_buffer_memory_cube: vk::DeviceMemory,
+
+    pub vertex_buffer_cuboid: vk::Buffer,
+    pub vertex_buffer_memory_cuboid: vk::DeviceMemory,
+
+    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,
+
+    pub rt_memory: Vec<u32>,
+}
+
+impl Scene {
+    pub unsafe fn prepare_data(&mut self, instance: &vulkanalia::Instance, device: &vulkanalia::Device, data: &mut AppData) -> Result<()> {
+        let mut rng = rand::thread_rng();
+        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)?;
+
+        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;
+                let cube = Cube {
+                    pos: vec3(x_index as f32, y_index as f32, 5.0),
+                    color: vec3(shade, 1.0, shade),
+                    tex_coord: vec2(0.0, 0.0)
+                };
+
+                oct_tree.set_cube(cube.clone());
+            }
+        }
+
+        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 {
+            let sized_index = self.sized_vertices.len();
+            let index = self.vertices.len();
+            match item {
+                Some(cube) => {
+                    /*if (cube.pos.x + cube.pos.y) as usize % 2 == 0{
+                        /**/
+                        let cuboid = Cuboid {
+                            pos: cube.pos,
+                            color: cube.color,
+                            tex_coord: cube.tex_coord,
+                            size: Vector3 {x: 1.0, y: 1.0, z: 1.0},
+                        };
+                        cuboid.draw(&data.topology, sized_index, self);
+                    }
+                    else {
+                        cube.draw(&data.topology, index, self);
+                    }*/
+                    cube.draw(&data.topology, index, self);
+                }
+                None => {}
+            }
+        }
+        
+        let mut memory_index = 1; // zero should be the location for the overall length (also will be the invalid memory allocation for pointing to a nonexistant neighbor)
+        for volume in &empty_volumes {
+            volume.borrow_mut().memory_start = memory_index;
+            memory_index += volume.borrow().get_buffer_mem_size() as usize;
+
+        }
+        for volume in &empty_volumes {
+            let quads = volume.borrow().to_quads();
+            for quad in quads {
+                quad.draw(&data.topology, self.rt_vertices.len(), self);
+            }
+        }
+        println!("Memory size is {} kB, max indes is {}", memory_index * 32 / 8 /1024 + 1, memory_index);
+        let mut volume_vec = vec![memory_index as u32; memory_index];
+        for volume in &empty_volumes {
+            volume_vec = volume.borrow().insert_into_memory(volume_vec);
+        }
+        println!("volume_vec print {:?}", volume_vec);
+        let mut empty_count = 0;
+        for element in &volume_vec {
+            if *element == memory_index as u32 {
+                empty_count += 1;
+            }
+        }
+        println!("empty elements count is  {}", empty_count);
+        self.rt_memory = volume_vec;
+        data.scene_rt_memory_size = (self.rt_memory.len() * 4) as u64; // size of the needed buffer size in bytes
+        
+        if self.vertices.len() != 0 {
+            (self.vertex_buffer_cube, self.vertex_buffer_memory_cube) = buffer::create_vertex_buffer(instance, device, &data, &self.vertices)?;
+            (self.index_buffer_cube, self.index_buffer_memory_cube) = buffer::create_index_buffer(&instance, &device, &data, &self.indices_cube)?;    
+        }
+        
+        if self.sized_vertices.len() != 0 {
+            (self.vertex_buffer_cuboid, self.vertex_buffer_memory_cuboid) = buffer::create_vertex_buffer(instance, device, &data, &self.sized_vertices)?;
+            (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(())
+
+    }
+
+    pub unsafe fn destroy(&mut self, device: &vulkanalia::Device) {
+        device.destroy_buffer(self.index_buffer_cube, None);
+        device.free_memory(self.index_buffer_memory_cube, None);
+
+        device.destroy_buffer(self.vertex_buffer_cube, None);
+        device.free_memory(self.vertex_buffer_memory_cube, None);
+
+        device.destroy_buffer(self.index_buffer_cuboid, None);
+        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.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);   
+    }
+}