RenderContext usage cleanup (#4446)

### What Some cleanup related to recent interior mutability changes: In a lot of places we can now pass just the RenderContext instead of several arguments, making a lot of code less complex. Also, "shared renderer data" is no longer needed either and is flattened out into the RenderContext. ### Checklist * [x] I have read and agree to [Contributor Guide](https://github.com/rerun-io/rerun/blob/main/CONTRIBUTING.md) and the [Code of Conduct](https://github.com/rerun-io/rerun/blob/main/CODE_OF_CONDUCT.md) * [x] I've included a screenshot or gif (if applicable) * [x] I have tested the web demo (if applicable): * Full build: [app.rerun.io](https://app.rerun.io/pr/4446/index.html) * Partial build: [app.rerun.io](https://app.rerun.io/pr/4446/index.html?manifest_url=https://app.rerun.io/version/nightly/examples_manifest.json) - Useful for quick testing when changes do not affect examples in any way * [x] The PR title and labels are set such as to maximize their usefulness for the next release's CHANGELOG - [PR Build Summary](https://build.rerun.io/pr/4446) - [Docs preview](https://rerun.io/preview/032f676245da9bbb08d2f6db1dd7ee33ccd09428/docs)  - [Examples preview](https://rerun.io/preview/032f676245da9bbb08d2f6db1dd7ee33ccd09428/examples)  - [Recent benchmark results](https://build.rerun.io/graphs/crates.html) - [Wasm size tracking](https://build.rerun.io/graphs/sizes.html)
rerun-io · Dec 6, 2023 · fa25e53 · fa25e53
1 parent 556c0b2
commit fa25e53
Show file tree

Hide file tree

Showing 18 changed files with 244 additions and 425 deletions.
diff --git a/crates/re_renderer/src/context.rs b/crates/re_renderer/src/context.rs
@@ -10,7 +10,7 @@ use crate::{
     renderer::Renderer,
     resource_managers::{MeshManager, TextureManager2D},
     wgpu_resources::{GpuRenderPipelinePoolMoveAccessor, WgpuResourcePools},
-    FileResolver, FileServer, FileSystem, RecommendedFileResolver,
+    FileServer, RecommendedFileResolver,
 };
 
 /// Any resource involving wgpu rendering which can be re-used across different scenes.
@@ -19,7 +19,12 @@ pub struct RenderContext {
     pub device: Arc<wgpu::Device>,
     pub queue: Arc<wgpu::Queue>,
 
-    pub(crate) shared_renderer_data: SharedRendererData,
+    pub(crate) config: RenderContextConfig,
+
+    /// Global bindings, always bound to 0 bind group slot zero.
+    /// [`Renderer`] are not allowed to use bind group 0 themselves!
+    pub(crate) global_bindings: GlobalBindings,
+
     renderers: RwLock<Renderers>,
     pub(crate) resolver: RecommendedFileResolver,
     #[cfg(all(not(target_arch = "wasm32"), debug_assertions))] // native debug build
@@ -41,32 +46,20 @@ pub struct RenderContext {
     pub gpu_resources: WgpuResourcePools, // Last due to drop order.
 }
 
-/// Immutable data that is shared between all [`Renderer`]
-pub struct SharedRendererData {
-    pub(crate) config: RenderContextConfig,
-
-    /// Global bindings, always bound to 0 bind group slot zero.
-    /// [`Renderer`] are not allowed to use bind group 0 themselves!
-    pub(crate) global_bindings: GlobalBindings,
-}
-
 /// Struct owning *all* [`Renderer`].
 /// [`Renderer`] are created lazily and stay around indefinitely.
 pub(crate) struct Renderers {
     renderers: concurrent::TypeMap,
 }
 
 impl Renderers {
-    pub fn get_or_create<Fs: FileSystem, R: 'static + Renderer + Send + Sync>(
+    pub fn get_or_create<R: 'static + Renderer + Send + Sync>(
         &mut self,
-        shared_data: &SharedRendererData,
-        resource_pools: &WgpuResourcePools,
-        device: &wgpu::Device,
-        resolver: &FileResolver<Fs>,
+        ctx: &RenderContext,
     ) -> &R {
         self.renderers.entry().or_insert_with(|| {
             re_tracing::profile_scope!("create_renderer", std::any::type_name::<R>());
-            R::create_renderer(shared_data, resource_pools, device, resolver)
+            R::create_renderer(ctx)
         })
     }
 
@@ -165,22 +158,8 @@ impl RenderContext {
             err_tracker
         };
 
-        let shared_renderer_data = SharedRendererData {
-            config,
-            global_bindings,
-        };
-
         let resolver = crate::new_recommended_file_resolver();
-        let mut renderers = RwLock::new(Renderers {
-            renderers: TypeMap::new(),
-        });
-
-        let mesh_manager = RwLock::new(MeshManager::new(renderers.get_mut().get_or_create(
-            &shared_renderer_data,
-            &gpu_resources,
-            &device,
-            &resolver,
-        )));
+        let mesh_manager = RwLock::new(MeshManager::new());
         let texture_manager_2d =
             TextureManager2D::new(device.clone(), queue.clone(), &gpu_resources.textures);
 
@@ -209,9 +188,12 @@ impl RenderContext {
             device,
             queue,
 
-            shared_renderer_data,
+            config,
+            global_bindings,
 
-            renderers,
+            renderers: RwLock::new(Renderers {
+                renderers: TypeMap::new(),
+            }),
 
             gpu_resources,
 
@@ -250,9 +232,7 @@ impl RenderContext {
         //          knowing that we're not _actually_ blocking.
         //
         //          For more details check https://github.com/gfx-rs/wgpu/issues/3601
-        if cfg!(target_arch = "wasm32")
-            && self.shared_renderer_data.config.device_caps.tier == DeviceTier::Gles
-        {
+        if cfg!(target_arch = "wasm32") && self.config.device_caps.tier == DeviceTier::Gles {
             self.device.poll(wgpu::Maintain::Wait);
             return;
         }
@@ -405,12 +385,7 @@ impl RenderContext {
         // If it wasn't there we have to add it.
         // This path is rare since it happens only once per renderer type in the lifetime of the ctx.
         // (we don't discard renderers ever)
-        self.renderers.write().get_or_create::<_, R>(
-            &self.shared_renderer_data,
-            &self.gpu_resources,
-            &self.device,
-            &self.resolver,
-        );
+        self.renderers.write().get_or_create::<R>(self);
 
         // Release write lock again and only take a read lock.
         // safe to unwrap since we just created it and nobody removes elements from the renderer.

diff --git a/crates/re_renderer/src/draw_phases/outlines.rs b/crates/re_renderer/src/draw_phases/outlines.rs
@@ -208,8 +208,7 @@ impl OutlineMaskProcessor {
         // ------------- Textures -------------
         let texture_pool = &ctx.gpu_resources.textures;
 
-        let mask_sample_count =
-            Self::mask_sample_count(&ctx.shared_renderer_data.config.device_caps);
+        let mask_sample_count = Self::mask_sample_count(&ctx.config.device_caps);
         let mask_texture_desc = crate::wgpu_resources::TextureDesc {
             label: format!("{instance_label}::mask_texture").into(),
             size: wgpu::Extent3d {
@@ -264,8 +263,7 @@ impl OutlineMaskProcessor {
 
         // ------------- Render Pipelines -------------
 
-        let screen_triangle_vertex_shader =
-            screen_triangle_vertex_shader(&ctx.gpu_resources, &ctx.device, &ctx.resolver);
+        let screen_triangle_vertex_shader = screen_triangle_vertex_shader(ctx);
         let jumpflooding_init_shader_module = if mask_sample_count == 1 {
             include_shader_module!("../../shader/outlines/jumpflooding_init.wgsl")
         } else {
@@ -274,54 +272,46 @@ impl OutlineMaskProcessor {
         let jumpflooding_init_desc = RenderPipelineDesc {
             label: "OutlineMaskProcessor::jumpflooding_init".into(),
             pipeline_layout: ctx.gpu_resources.pipeline_layouts.get_or_create(
-                &ctx.device,
+                ctx,
                 &PipelineLayoutDesc {
                     label: "OutlineMaskProcessor::jumpflooding_init".into(),
                     entries: vec![bind_group_layout_jumpflooding_init],
                 },
-                &ctx.gpu_resources.bind_group_layouts,
             ),
             vertex_entrypoint: "main".into(),
             vertex_handle: screen_triangle_vertex_shader,
             fragment_entrypoint: "main".into(),
-            fragment_handle: ctx.gpu_resources.shader_modules.get_or_create(
-                &ctx.device,
-                &ctx.resolver,
-                &jumpflooding_init_shader_module,
-            ),
+            fragment_handle: ctx
+                .gpu_resources
+                .shader_modules
+                .get_or_create(ctx, &jumpflooding_init_shader_module),
             vertex_buffers: smallvec![],
             render_targets: smallvec![Some(Self::VORONOI_FORMAT.into())],
             primitive: wgpu::PrimitiveState::default(),
             depth_stencil: None,
             multisample: wgpu::MultisampleState::default(),
         };
-        let render_pipeline_jumpflooding_init = ctx.gpu_resources.render_pipelines.get_or_create(
-            &ctx.device,
-            &jumpflooding_init_desc,
-            &ctx.gpu_resources.pipeline_layouts,
-            &ctx.gpu_resources.shader_modules,
-        );
+        let render_pipeline_jumpflooding_init = ctx
+            .gpu_resources
+            .render_pipelines
+            .get_or_create(ctx, &jumpflooding_init_desc);
         let render_pipeline_jumpflooding_step = ctx.gpu_resources.render_pipelines.get_or_create(
-            &ctx.device,
+            ctx,
             &RenderPipelineDesc {
                 label: "OutlineMaskProcessor::jumpflooding_step".into(),
                 pipeline_layout: ctx.gpu_resources.pipeline_layouts.get_or_create(
-                    &ctx.device,
+                    ctx,
                     &PipelineLayoutDesc {
                         label: "OutlineMaskProcessor::jumpflooding_step".into(),
                         entries: vec![bind_group_layout_jumpflooding_step],
                     },
-                    &ctx.gpu_resources.bind_group_layouts,
                 ),
                 fragment_handle: ctx.gpu_resources.shader_modules.get_or_create(
-                    &ctx.device,
-                    &ctx.resolver,
+                    ctx,
                     &include_shader_module!("../../shader/outlines/jumpflooding_step.wgsl"),
                 ),
                 ..jumpflooding_init_desc
             },
-            &ctx.gpu_resources.pipeline_layouts,
-            &ctx.gpu_resources.shader_modules,
         );
 
         Self {

diff --git a/crates/re_renderer/src/draw_phases/picking_layer.rs b/crates/re_renderer/src/draw_phases/picking_layer.rs
@@ -204,11 +204,7 @@ impl PickingLayerProcessor {
             },
         );
 
-        let direct_depth_readback = ctx
-            .shared_renderer_data
-            .config
-            .device_caps
-            .support_depth_readback();
+        let direct_depth_readback = ctx.config.device_caps.support_depth_readback();
 
         let picking_depth_target = ctx.gpu_resources.textures.alloc(
             &ctx.device,
@@ -259,7 +255,7 @@ impl PickingLayerProcessor {
             frame_uniform_buffer_content,
         );
 
-        let bind_group_0 = ctx.shared_renderer_data.global_bindings.create_bind_group(
+        let bind_group_0 = ctx.global_bindings.create_bind_group(
             &ctx.gpu_resources,
             &ctx.device,
             frame_uniform_buffer,
@@ -535,30 +531,24 @@ impl DepthReadbackWorkaround {
         );
 
         let render_pipeline = ctx.gpu_resources.render_pipelines.get_or_create(
-            &ctx.device,
+            ctx,
             &RenderPipelineDesc {
                 label: "DepthCopyWorkaround::render_pipeline".into(),
                 pipeline_layout: ctx.gpu_resources.pipeline_layouts.get_or_create(
-                    &ctx.device,
+                    ctx,
                     &PipelineLayoutDesc {
                         label: "DepthCopyWorkaround::render_pipeline".into(),
-                        entries: vec![
-                            ctx.shared_renderer_data.global_bindings.layout,
-                            bind_group_layout,
-                        ],
+                        entries: vec![ctx.global_bindings.layout, bind_group_layout],
                     },
-                    &ctx.gpu_resources.bind_group_layouts,
                 ),
                 vertex_entrypoint: "main".into(),
                 vertex_handle: ctx.gpu_resources.shader_modules.get_or_create(
-                    &ctx.device,
-                    &ctx.resolver,
+                    ctx,
                     &include_shader_module!("../../shader/screen_triangle.wgsl"),
                 ),
                 fragment_entrypoint: "main".into(),
                 fragment_handle: ctx.gpu_resources.shader_modules.get_or_create(
-                    &ctx.device,
-                    &ctx.resolver,
+                    ctx,
                     &include_shader_module!("../../shader/copy_texture.wgsl"),
                 ),
                 vertex_buffers: smallvec![],
@@ -571,8 +561,6 @@ impl DepthReadbackWorkaround {
                 depth_stencil: None,
                 multisample: wgpu::MultisampleState::default(),
             },
-            &ctx.gpu_resources.pipeline_layouts,
-            &ctx.gpu_resources.shader_modules,
         );
 
         Self {

diff --git a/crates/re_renderer/src/renderer/compositor.rs b/crates/re_renderer/src/renderer/compositor.rs
@@ -1,18 +1,17 @@
 use crate::{
     allocator::create_and_fill_uniform_buffer,
-    context::SharedRendererData,
     include_shader_module,
     renderer::{screen_triangle_vertex_shader, DrawData, DrawError, Renderer},
     view_builder::ViewBuilder,
     wgpu_resources::{
         BindGroupDesc, BindGroupEntry, BindGroupLayoutDesc, GpuBindGroup, GpuBindGroupLayoutHandle,
         GpuRenderPipelineHandle, GpuRenderPipelinePoolAccessor, GpuTexture, PipelineLayoutDesc,
-        RenderPipelineDesc, WgpuResourcePools,
+        RenderPipelineDesc,
     },
     OutlineConfig, Rgba,
 };
 
-use crate::{DrawPhase, FileResolver, FileSystem, RenderContext};
+use crate::{DrawPhase, RenderContext};
 
 use smallvec::smallvec;
 
@@ -99,14 +98,9 @@ impl CompositorDrawData {
 impl Renderer for Compositor {
     type RendererDrawData = CompositorDrawData;
 
-    fn create_renderer<Fs: FileSystem>(
-        shared_data: &SharedRendererData,
-        pools: &WgpuResourcePools,
-        device: &wgpu::Device,
-        resolver: &FileResolver<Fs>,
-    ) -> Self {
-        let bind_group_layout = pools.bind_group_layouts.get_or_create(
-            device,
+    fn create_renderer(ctx: &RenderContext) -> Self {
+        let bind_group_layout = ctx.gpu_resources.bind_group_layouts.get_or_create(
+            &ctx.device,
             &BindGroupLayoutDesc {
                 label: "Compositor::bind_group_layout".into(),
                 entries: vec![
@@ -148,47 +142,41 @@ impl Renderer for Compositor {
             },
         );
 
-        let vertex_handle = screen_triangle_vertex_shader(pools, device, resolver);
+        let vertex_handle = screen_triangle_vertex_shader(ctx);
 
         let render_pipeline_descriptor = RenderPipelineDesc {
             label: "CompositorDrawData::render_pipeline_regular".into(),
-            pipeline_layout: pools.pipeline_layouts.get_or_create(
-                device,
+            pipeline_layout: ctx.gpu_resources.pipeline_layouts.get_or_create(
+                ctx,
                 &PipelineLayoutDesc {
                     label: "compositor".into(),
-                    entries: vec![shared_data.global_bindings.layout, bind_group_layout],
+                    entries: vec![ctx.global_bindings.layout, bind_group_layout],
                 },
-                &pools.bind_group_layouts,
             ),
             vertex_entrypoint: "main".into(),
             vertex_handle,
             fragment_entrypoint: "main".into(),
-            fragment_handle: pools.shader_modules.get_or_create(
-                device,
-                resolver,
-                &include_shader_module!("../../shader/composite.wgsl"),
-            ),
+            fragment_handle: ctx
+                .gpu_resources
+                .shader_modules
+                .get_or_create(ctx, &include_shader_module!("../../shader/composite.wgsl")),
             vertex_buffers: smallvec![],
-            render_targets: smallvec![Some(shared_data.config.output_format_color.into())],
+            render_targets: smallvec![Some(ctx.config.output_format_color.into())],
             primitive: wgpu::PrimitiveState::default(),
             depth_stencil: None,
             multisample: wgpu::MultisampleState::default(),
         };
-        let render_pipeline_regular = pools.render_pipelines.get_or_create(
-            device,
-            &render_pipeline_descriptor,
-            &pools.pipeline_layouts,
-            &pools.shader_modules,
-        );
-        let render_pipeline_screenshot = pools.render_pipelines.get_or_create(
-            device,
+        let render_pipeline_regular = ctx
+            .gpu_resources
+            .render_pipelines
+            .get_or_create(ctx, &render_pipeline_descriptor);
+        let render_pipeline_screenshot = ctx.gpu_resources.render_pipelines.get_or_create(
+            ctx,
             &RenderPipelineDesc {
                 label: "CompositorDrawData::render_pipeline_screenshot".into(),
                 render_targets: smallvec![Some(ViewBuilder::SCREENSHOT_COLOR_FORMAT.into())],
                 ..render_pipeline_descriptor
             },
-            &pools.pipeline_layouts,
-            &pools.shader_modules,
         );
 
         Compositor {