update ResourceProvider::update to actually use read-only world

bevy_render/src/render_resource/resource_provider.rs

@@ -10,8 +10,7 @@ pub trait ResourceProvider {
     ) {
     }
 
-    // TODO: make this read-only
+    fn update(&mut self, _render_context: &mut dyn RenderContext, _world: &World, _resources: &Resources) {
-    fn update(&mut self, _render_context: &mut dyn RenderContext, _world: &mut World, _resources: &Resources) {
     }
 
     // TODO: remove this

bevy_render/src/render_resource/resource_providers/camera2d_resource_provider.rs

@@ -27,8 +27,28 @@ impl Camera2dResourceProvider {
             window_resized_event_reader,
         }
     }
+}
 
-    fn update_read_only(
+impl ResourceProvider for Camera2dResourceProvider {
+    fn initialize(
+        &mut self,
+        render_context: &mut dyn RenderContext,
+        _world: &mut World,
+        resources: &Resources,
+    ) {
+        let buffer = render_context.resources_mut().create_buffer(BufferInfo {
+            size: std::mem::size_of::<[[f32; 4]; 4]>(),
+            buffer_usage: BufferUsage::COPY_DST | BufferUsage::UNIFORM,
+            ..Default::default()
+        });
+
+        let mut render_resource_assignments =
+            resources.get_mut::<RenderResourceAssignments>().unwrap();
+        render_resource_assignments.set(resource_name::uniform::CAMERA2D, buffer);
+        self.camera_buffer = Some(buffer);
+    }
+
+    fn update(
         &mut self,
         render_context: &mut dyn RenderContext,
         world: &World,
@@ -43,8 +63,7 @@ impl Camera2dResourceProvider {
 
         if let Some(_) = primary_window_resized_event {
             let matrix_size = std::mem::size_of::<[[f32; 4]; 4]>();
-            for (camera, _) in <(Read<Camera>, Read<ActiveCamera2d>)>::query().iter(world)
+            for (camera, _) in <(Read<Camera>, Read<ActiveCamera2d>)>::query().iter(world) {
-            {
                 let camera_matrix: [[f32; 4]; 4] = camera.view_matrix.to_cols_array_2d();
 
                 if let Some(old_tmp_buffer) = self.tmp_buffer {
@@ -73,32 +92,3 @@ impl Camera2dResourceProvider {
         }
     }
 }
-
-impl ResourceProvider for Camera2dResourceProvider {
-    fn initialize(
-        &mut self,
-        render_context: &mut dyn RenderContext,
-        _world: &mut World,
-        resources: &Resources,
-    ) {
-        let buffer = render_context.resources_mut().create_buffer(BufferInfo {
-            size: std::mem::size_of::<[[f32; 4]; 4]>(),
-            buffer_usage: BufferUsage::COPY_DST | BufferUsage::UNIFORM,
-            ..Default::default()
-        });
-
-        let mut render_resource_assignments =
-            resources.get_mut::<RenderResourceAssignments>().unwrap();
-        render_resource_assignments.set(resource_name::uniform::CAMERA2D, buffer);
-        self.camera_buffer = Some(buffer);
-    }
-
-    fn update(
-        &mut self,
-        render_context: &mut dyn RenderContext,
-        world: &mut World,
-        resources: &Resources,
-    ) {
-        self.update_read_only(render_context, world, resources);
-    }
-}

bevy_render/src/render_resource/resource_providers/camera_resource_provider.rs

@@ -28,8 +28,33 @@ impl CameraResourceProvider {
             window_resized_event_reader,
         }
     }
+}
 
-    pub fn update_read_only(&mut self, world: &World, resources: &Resources, render_context: &mut dyn RenderContext) {
+impl ResourceProvider for CameraResourceProvider {
+    fn initialize(
+        &mut self,
+        render_context: &mut dyn RenderContext,
+        _world: &mut World,
+        resources: &Resources,
+    ) {
+        let buffer = render_context.resources_mut().create_buffer(BufferInfo {
+            size: std::mem::size_of::<[[f32; 4]; 4]>(),
+            buffer_usage: BufferUsage::COPY_DST | BufferUsage::UNIFORM,
+            ..Default::default()
+        });
+
+        let mut render_resource_assignments =
+            resources.get_mut::<RenderResourceAssignments>().unwrap();
+        render_resource_assignments.set(resource_name::uniform::CAMERA, buffer);
+        self.camera_buffer = Some(buffer);
+    }
+
+    fn update(
+        &mut self,
+        render_context: &mut dyn RenderContext,
+        world: &World,
+        resources: &Resources,
+    ) {
         let window_resized_events = resources.get::<Events<WindowResized>>().unwrap();
         let primary_window_resized_event = window_resized_events
             .iter(&mut self.window_resized_event_reader)
@@ -70,32 +95,3 @@ impl CameraResourceProvider {
         }
     }
 }
-
-impl ResourceProvider for CameraResourceProvider {
-    fn initialize(
-        &mut self,
-        render_context: &mut dyn RenderContext,
-        _world: &mut World,
-        resources: &Resources,
-    ) {
-        let buffer = render_context.resources_mut().create_buffer(BufferInfo {
-            size: std::mem::size_of::<[[f32; 4]; 4]>(),
-            buffer_usage: BufferUsage::COPY_DST | BufferUsage::UNIFORM,
-            ..Default::default()
-        });
-
-        let mut render_resource_assignments =
-            resources.get_mut::<RenderResourceAssignments>().unwrap();
-        render_resource_assignments.set(resource_name::uniform::CAMERA, buffer);
-        self.camera_buffer = Some(buffer);
-    }
-
-    fn update(
-        &mut self,
-        render_context: &mut dyn RenderContext,
-        world: &mut World,
-        resources: &Resources,
-    ) {
-        self.update_read_only(world, resources, render_context);
-    }
-}

bevy_render/src/render_resource/resource_providers/frame_texture_resource_provider.rs

@@ -21,8 +21,10 @@ impl FrameTextureResourceProvider {
             height: 0,
         }
     }
+}
 
-    pub fn update(&mut self, render_context: &mut dyn RenderContext, resources: &Resources) {
+impl ResourceProvider for FrameTextureResourceProvider {
+    fn update(&mut self, render_context: &mut dyn RenderContext, _world: &World, resources: &Resources) {
         let windows = resources.get::<Windows>().unwrap();
         let window = windows.get_primary().unwrap();
 
@@ -44,9 +46,3 @@ impl FrameTextureResourceProvider {
         }
     }
 }
-
-impl ResourceProvider for FrameTextureResourceProvider {
-    fn update(&mut self, render_context: &mut dyn RenderContext, _world: &mut World, resources: &Resources) {
-        self.update(render_context, resources)
-    }
-}

bevy_render/src/render_resource/resource_providers/light_resource_provider.rs

@@ -3,7 +3,8 @@ use crate::{
         resource_name, BufferInfo, BufferUsage, RenderResource, RenderResourceAssignments,
         ResourceProvider,
     },
-    Light, LightRaw, renderer_2::RenderContext,
+    renderer_2::RenderContext,
+    Light, LightRaw,
 };
 use bevy_transform::prelude::{LocalToWorld, Translation};
 use legion::prelude::*;
@@ -33,7 +34,35 @@ impl LightResourceProvider {
             tmp_count_buffer: None,
         }
     }
-    fn update_read_only(&mut self, render_context: &mut dyn RenderContext, world: &World) {
+}
+
+impl ResourceProvider for LightResourceProvider {
+    fn initialize(
+        &mut self,
+        render_context: &mut dyn RenderContext,
+        _world: &mut World,
+        resources: &Resources,
+    ) {
+        let light_uniform_size =
+            std::mem::size_of::<LightCount>() + self.max_lights * std::mem::size_of::<LightRaw>();
+
+        let buffer = render_context.resources_mut().create_buffer(BufferInfo {
+            size: light_uniform_size,
+            buffer_usage: BufferUsage::UNIFORM | BufferUsage::COPY_SRC | BufferUsage::COPY_DST,
+            ..Default::default()
+        });
+        let mut render_resource_assignments =
+            resources.get_mut::<RenderResourceAssignments>().unwrap();
+        render_resource_assignments.set(resource_name::uniform::LIGHTS, buffer);
+        self.light_buffer = Some(buffer);
+    }
+
+    fn update(
+        &mut self,
+        render_context: &mut dyn RenderContext,
+        world: &World,
+        _resources: &Resources,
+    ) {
         if self.lights_are_dirty {
             let light_query = <(Read<Light>, Read<LocalToWorld>, Read<Translation>)>::query();
             let light_count = light_query.iter(world).count();
@@ -101,29 +130,3 @@ impl LightResourceProvider {
         }
     }
 }
-
-impl ResourceProvider for LightResourceProvider {
-    fn initialize(
-        &mut self,
-        render_context: &mut dyn RenderContext,
-        _world: &mut World,
-        resources: &Resources,
-    ) {
-        let light_uniform_size =
-            std::mem::size_of::<LightCount>() + self.max_lights * std::mem::size_of::<LightRaw>();
-
-        let buffer = render_context.resources_mut().create_buffer(BufferInfo {
-            size: light_uniform_size,
-            buffer_usage: BufferUsage::UNIFORM | BufferUsage::COPY_SRC | BufferUsage::COPY_DST,
-            ..Default::default()
-        });
-        let mut render_resource_assignments =
-            resources.get_mut::<RenderResourceAssignments>().unwrap();
-        render_resource_assignments.set(resource_name::uniform::LIGHTS, buffer);
-        self.light_buffer = Some(buffer);
-    }
-
-    fn update(&mut self, render_context: &mut dyn RenderContext, world: &mut World, _resources: &Resources) {
-        self.update_read_only(render_context, world);
-    }
-}

bevy_render/src/render_resource/resource_providers/mesh_resource_provider.rs

@@ -91,7 +91,7 @@ impl ResourceProvider for MeshResourceProvider {
         vertex_buffer_descriptors.set(Vertex::get_vertex_buffer_descriptor().cloned().unwrap());
     }
 
-    fn update(&mut self, _render_context: &mut dyn RenderContext, _world: &mut World, _resources: &Resources) {
+    fn update(&mut self, _render_context: &mut dyn RenderContext, _world: &World, _resources: &Resources) {
     }
 
     fn finish_update(

bevy_render/src/render_resource/resource_providers/uniform_resource_provider.rs

@@ -128,18 +128,6 @@ where
         }
     }
 
-    fn update_readonly(
-        &mut self,
-        _render_context: &mut dyn RenderContext,
-        world: &World,
-        resources: &Resources,
-    ) {
-        self.reset_buffer_array_status_counts();
-        self.update_uniforms_info(world);
-        self.update_uniform_handles_info(world, resources);
-    }
-
-
     fn reset_buffer_array_status_counts(&mut self) {
         for buffer_status in self.uniform_buffer_status.iter_mut() {
             if let Some((_name, buffer_status)) = buffer_status {
@@ -734,10 +722,12 @@ where
     fn update(
         &mut self,
         _render_context: &mut dyn RenderContext,
-        world: &mut World,
+        world: &World,
         resources: &Resources,
     ) {
-        self.update_readonly(_render_context, world, resources);
+        self.reset_buffer_array_status_counts();
+        self.update_uniforms_info(world);
+        self.update_uniform_handles_info(world, resources);
     }
 
     fn finish_update(