Update Rust crate ron to 0.9.0

engine/src/scene/rendering/mod.rs

@@ -22,6 +22,7 @@ pub trait RenderingFrontEnd {
     // scene rendering
     fn process(
         &mut self,
+        changed: bool,
         content: Vec<&EntityObject>,
         buffer_recorder: &mut CommandBufferRecorder<'_>,
         images: &TargetMode<Vec<Arc<Image>>>,

engine/src/scene/rendering/rasterizer/deferred/mod.rs

@@ -406,6 +406,7 @@ impl RenderingFrontEnd for Rasterizer {
 
     fn process(
         &mut self,
+        _changed: bool,
         content: Vec<&EntityObject>,
         buffer_recorder: &mut CommandBufferRecorder<'_>,
         _images: &TargetMode<Vec<Arc<Image>>>,

engine/src/scene/rendering/rasterizer/traditional/mod.rs

@@ -680,6 +680,7 @@ impl RenderingFrontEnd for TraditionalRasterizer {
 
     fn process(
         &mut self,
+        _changed: bool,
         content: Vec<&EntityObject>,
         buffer_recorder: &mut CommandBufferRecorder<'_>,
         _images: &TargetMode<Vec<Arc<Image>>>,

engine/src/scene/rendering/raytracer/raytracer.rs

@@ -65,6 +65,8 @@ where
     width: u32,
     height: u32,
 
+    vertex_count: u64,
+
     renderer: T,
 }
 
@@ -147,6 +149,8 @@ where
 
             width,
             height,
+
+            vertex_count: 0,
         })
     }
 
@@ -601,6 +605,7 @@ where
     // scene rendering
     fn process(
         &mut self,
+        changed: bool,
         content: Vec<&EntityObject>,
         buffer_recorder: &mut CommandBufferRecorder<'_>,
         images: &TargetMode<Vec<Arc<Image>>>,
@@ -614,65 +619,73 @@ where
         self.renderer.invalidate();
         self.animator.invalidate();
 
-        // gather textures and materials from all objects
+        if changed {
-        let (textures, materials, vertex_count) = Self::gather_descriptor_buffers(&content)?;
+            let mut recompile = false;
 
-        let mut recompile = false;
+            // gather textures and materials from all objects
+            let (textures, materials, vertex_count) = Self::gather_descriptor_buffers(&content)?;
+            self.vertex_count = vertex_count;
 
-        // update material descriptor
+            // update material descriptor
-        if !materials.is_empty() {
+            if !materials.is_empty() {
-            let materials_ref: Vec<&Arc<Buffer<Material>>> = materials.iter().collect();
+                let materials_ref: Vec<&Arc<Buffer<Material>>> = materials.iter().collect();
 
-            if materials_ref.len() as u32 > self.max_material_count {
+                if materials_ref.len() as u32 > self.max_material_count {
-                while materials_ref.len() as u32 > self.max_material_count {
+                    while materials_ref.len() as u32 > self.max_material_count {
-                    self.max_material_count *= 2;
+                        self.max_material_count *= 2;
+                    }
+
+                    self.material_desc_set = Self::create_material_descriptor_set(
+                        &self.device,
+                        self.max_material_count,
+                    )?;
+
+                    recompile = true;
                 }
 
-                self.material_desc_set =
+                self.material_desc_set
-                    Self::create_material_descriptor_set(&self.device, self.max_material_count)?;
+                    .update(&[DescriptorWrite::uniform_buffers(0, &materials_ref)])?;
-
-                recompile = true;
             }
 
-            self.material_desc_set
+            // update texture descriptor
-                .update(&[DescriptorWrite::uniform_buffers(0, &materials_ref)])?;
+            if !textures.is_empty() {
-        }
+                let textures_ref: Vec<&Arc<Image>> = textures.iter().collect();
 
-        // update texture descriptor
+                if textures_ref.len() as u32 > self.max_texture_count {
-        if !textures.is_empty() {
+                    while textures_ref.len() as u32 > self.max_texture_count {
-            let textures_ref: Vec<&Arc<Image>> = textures.iter().collect();
+                        self.max_texture_count *= 2;
+                    }
 
-            if textures_ref.len() as u32 > self.max_texture_count {
+                    self.texture_desc_set =
-                while textures_ref.len() as u32 > self.max_texture_count {
+                        Self::create_texture_descriptor_set(&self.device, self.max_texture_count)?;
-                    self.max_texture_count *= 2;
+
+                    recompile = true;
                 }
 
-                self.texture_desc_set =
+                self.texture_desc_set
-                    Self::create_texture_descriptor_set(&self.device, self.max_texture_count)?;
+                    .update(&[DescriptorWrite::combined_samplers(0, &textures_ref)])?;
-
-                recompile = true;
             }
 
-            self.texture_desc_set
+            if recompile {
-                .update(&[DescriptorWrite::combined_samplers(0, &textures_ref)])?;
+                self.renderer.recompile(&[
-        }
+                    &self.scene_desc_set,
-
+                    &self.material_desc_set,
-        if recompile {
+                    &self.texture_desc_set,
-            self.renderer.recompile(&[
+                    &self.light_descriptor_set,
-                &self.scene_desc_set,
+                    &self.light_info_desc_set,
-                &self.material_desc_set,
+                ])?;
-                &self.texture_desc_set,
+            }
-                &self.light_descriptor_set,
-                &self.light_info_desc_set,
-            ])?;
         }
 
         let index = *indices.mono();
 
-        if let Some(scene_buffer) =
+        if let Some(scene_buffer) = self.animator.animate(
-            self.animator
+            &content,
-                .animate(&content, vertex_count, buffer_recorder, index, &self.view)?
+            self.vertex_count,
-        {
+            buffer_recorder,
+            index,
+            &self.view,
+        )? {
             self.scene_desc_set
                 .update(&[DescriptorWrite::storage_buffers(0, &[scene_buffer])])?;
         }

engine/src/scene/scene/scene_base.rs

@@ -463,8 +463,13 @@ impl TScene for Scene {
             #[cfg(feature = "timings")]
             let before = Instant::now();
 
-            self.renderer
+            self.renderer.process(
-                .process(content, buffer_recorder, images, indices)?;
+                world.had_entity_changes(),
+                content,
+                buffer_recorder,
+                images,
+                indices,
+            )?;
 
             #[cfg(feature = "timings")]
             self.timings