adds naive update for light and volumes

src/scene/mod.rs

@@ -59,8 +59,10 @@ pub struct Scene {
 
     pub oct_trees: Vec<Vec<Vec<Rc<RefCell<OctTree<Cube>>>>>>,
 
-    point_lights: Vec<Rc<RefCell<PointLight>>>,
-    directional_lights: Vec<Rc<RefCell<DirectionalLight>>>,
+    pub point_lights: Vec<Rc<RefCell<PointLight>>>,
+    pub directional_lights: Vec<Rc<RefCell<DirectionalLight>>>,
+
+    pub memorizables: Vec<Rc<RefCell<dyn Memorizable>>>,
 }
 
 impl Scene {
@@ -121,48 +123,27 @@ impl Scene {
             z_index += 1;
         }
         println!("number of empty volumes is {}", empty_volumes.len());
-        
-        let mut memory_index = 6; 
-        // 0 - location for the maximum number of lights referenced per chunk (also will be the invalid memory allocation for pointing to a nonexistant neighbor)
-        // 1 - location for the max iterations per light
-        // 2 - diffuse raster samples (2*n + 1) * (2*n + 1) so as to always have at least the central fragment covered
-        // 3 - diffuse raster size
-        // 4 - max recursive rays
-        // 5 - diffuse rays per hit
-        for light in LightsIter::new(self) {
-            light.borrow_mut().set_memory_start(memory_index);
-            memory_index += light.borrow_mut().get_buffer_mem_size(data) as usize;
+
+        for light in &self.point_lights {
+            self.memorizables.push(light.clone());
+        }
+
+        for light in &self.directional_lights {
+            self.memorizables.push(light.clone());
         }
 
         for volume in &empty_volumes {
-            volume.borrow_mut().set_memory_start(memory_index);
-            memory_index += volume.borrow().get_buffer_mem_size(data) as usize;
-
+            self.memorizables.push(volume.clone());
         }
+
+        self.update_memory(data, false);
+
         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![data.num_lights_per_volume; memory_index];
-        volume_vec[1] = data.max_iterations_per_light;
-        volume_vec[2] = data.diffuse_raster_steps;
-        volume_vec[3] = u32::from_ne_bytes(data.diffuse_raster_size.to_ne_bytes());
-        volume_vec[4] = data.max_recursive_rays;
-        volume_vec[5] = data.diffuse_rays_per_hit;
-        
-        for volume in &empty_volumes {
-            volume_vec = volume.borrow().insert_into_memory(volume_vec, data, &self);
-        }
-        for light in LightsIter::new(self) {
-            volume_vec = light.borrow().insert_into_memory(volume_vec, data, &self);
-        }
-        //println!("volume_vec print {:?}", volume_vec);
-
-        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)?;
@@ -184,6 +165,55 @@ impl Scene {
 
     }
 
+    pub fn is_dirty(&self) -> bool {
+        for memorizable in &self.memorizables {
+            if memorizable.borrow().is_dirty() {
+                return true
+            }
+        }
+        return false
+    }
+
+    pub fn update_memory(&mut self, data: &mut AppData, reuse_memory: bool) {
+        // reuse_memory controls whether a fresh data vector is created or the existing one is used if it is the right size
+        let mut memory_index = 6; 
+        // 0 - location for the maximum number of lights referenced per chunk (also will be the invalid memory allocation for pointing to a nonexistant neighbor)
+        // 1 - location for the max iterations per light
+        // 2 - diffuse raster samples (2*n + 1) * (2*n + 1) so as to always have at least the central fragment covered
+        // 3 - diffuse raster size
+        // 4 - max recursive rays
+        // 5 - diffuse rays per hit
+        for memorizable in &self.memorizables {
+            memorizable.borrow_mut().set_memory_start(memory_index);
+            memory_index += memorizable.borrow_mut().get_buffer_mem_size(data) as usize;
+        }
+
+        //println!("Memory size is {} kB, max indes is {}", memory_index * 32 / 8 /1024 + 1, memory_index);
+        let mut volume_vec;
+        let needs_overwrite;
+        if !reuse_memory || memory_index != self.rt_memory.len() {
+            volume_vec = vec![data.num_lights_per_volume; memory_index];
+            needs_overwrite = true;
+        } else {
+            needs_overwrite = false;
+            volume_vec = self.rt_memory.clone();
+        }
+        volume_vec[1] = data.max_iterations_per_light;
+        volume_vec[2] = data.diffuse_raster_steps;
+        volume_vec[3] = u32::from_ne_bytes(data.diffuse_raster_size.to_ne_bytes());
+        volume_vec[4] = data.max_recursive_rays;
+        volume_vec[5] = data.diffuse_rays_per_hit;
+        
+        for memorizable in &self.memorizables {
+            if needs_overwrite || memorizable.borrow().is_dirty() {
+                volume_vec = memorizable.borrow_mut().insert_into_memory(volume_vec, data, &self);
+            }
+        }
+
+        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
+    }
+
     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);