Update Rust crate ron to 0.9.0

engine/src/scene/rendering/mod.rs

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

engine/src/scene/scene/scene_base.rs

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