indentation, comment and naming fixes

crates/re_renderer/src/context.rs

@@ -396,31 +396,26 @@ impl RenderContext {
     }
 
     /// Gets a renderer with the specified type, initializing it if necessary.
-    pub fn get_renderer<R: 'static + Renderer + Send + Sync>(
-        &self,
-    ) -> MappedRwLockReadGuard<'_, R> {
+    pub fn renderer<R: 'static + Renderer + Send + Sync>(&self) -> MappedRwLockReadGuard<'_, R> {
+        // Most likely we already have the renderer. Take a read lock and return it.
+        if let Ok(renderer) =
+            parking_lot::RwLockReadGuard::try_map(self.renderers.read(), |r| r.get::<R>())
         {
-            // Most likely we already have the renderer. Take a read lock and return it.
-            if let Ok(renderer) =
-                parking_lot::RwLockReadGuard::try_map(self.renderers.read(), |r| r.get::<R>())
-            {
-                return renderer;
-            }
+            return renderer;
         }
 
         // 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.shared_renderer_data,
+            &self.gpu_resources,
+            &self.device,
+            &self.resolver,
+        );
+
         // Release write lock again and only take a read lock.
-        // safe to unwrap since we just created it.
+        // safe to unwrap since we just created it and nobody removes elements from the renderer.
         parking_lot::RwLockReadGuard::map(self.renderers.read(), |r| r.get::<R>().unwrap())
     }
 

crates/re_renderer/src/renderer/compositor.rs

@@ -54,7 +54,7 @@ impl CompositorDrawData {
         outline_final_voronoi: Option<&GpuTexture>,
         outline_config: &Option<OutlineConfig>,
     ) -> Self {
-        let compositor = ctx.get_renderer::<Compositor>();
+        let compositor = ctx.renderer::<Compositor>();
 
         let outline_config = outline_config.clone().unwrap_or(OutlineConfig {
             outline_radius_pixel: 0.0,

crates/re_renderer/src/renderer/debug_overlay.rs

@@ -77,7 +77,7 @@ impl DebugOverlayDrawData {
         screen_resolution: glam::UVec2,
         overlay_rect: RectInt,
     ) -> Result<Self, DebugOverlayError> {
-        let debug_overlay = ctx.get_renderer::<DebugOverlayRenderer>();
+        let debug_overlay = ctx.renderer::<DebugOverlayRenderer>();
 
         let mode = match debug_texture
             .texture

crates/re_renderer/src/renderer/depth_cloud.rs

@@ -243,7 +243,7 @@ impl DepthCloudDrawData {
             radius_boost_in_ui_points_for_outlines,
         } = depth_clouds;
 
-        let renderer = ctx.get_renderer::<DepthCloudRenderer>();
+        let renderer = ctx.renderer::<DepthCloudRenderer>();
         let bg_layout = renderer.bind_group_layout;
 
         if depth_clouds.is_empty() {

crates/re_renderer/src/renderer/generic_skybox.rs

@@ -31,7 +31,7 @@ impl DrawData for GenericSkyboxDrawData {
 
 impl GenericSkyboxDrawData {
     pub fn new(ctx: &RenderContext) -> Self {
-        let _ = ctx.get_renderer::<GenericSkybox>(); // TODO(andreas): This should happen automatically.
+        let _ = ctx.renderer::<GenericSkybox>(); // TODO(andreas): This line ensures that the renderer exists. Currently this needs to be done ahead of time, but should be fully automatic!
         GenericSkyboxDrawData {}
     }
 }

crates/re_renderer/src/renderer/lines.rs

@@ -376,7 +376,7 @@ impl LineDrawData {
         ctx: &RenderContext,
         line_builder: LineStripSeriesBuilder,
     ) -> Result<Self, LineDrawDataError> {
-        let line_renderer = ctx.get_renderer::<LineRenderer>();
+        let line_renderer = ctx.renderer::<LineRenderer>();
 
         if line_builder.strips.is_empty() {
             return Ok(LineDrawData {

crates/re_renderer/src/renderer/mesh_renderer.rs

@@ -157,7 +157,7 @@ impl MeshDrawData {
     pub fn new(ctx: &RenderContext, instances: &[MeshInstance]) -> anyhow::Result<Self> {
         re_tracing::profile_function!();
 
-        let _mesh_renderer = ctx.get_renderer::<MeshRenderer>();
+        let _mesh_renderer = ctx.renderer::<MeshRenderer>();
 
         if instances.is_empty() {
             return Ok(MeshDrawData {

crates/re_renderer/src/renderer/point_cloud.rs

@@ -186,7 +186,7 @@ impl PointCloudDrawData {
     ) -> Result<Self, PointCloudDrawDataError> {
         re_tracing::profile_function!();
 
-        let point_renderer = ctx.get_renderer::<PointCloudRenderer>();
+        let point_renderer = ctx.renderer::<PointCloudRenderer>();
 
         let vertices = builder.vertices.as_slice();
         let batches = builder.batches.as_slice();

crates/re_renderer/src/renderer/rectangles.rs

@@ -400,7 +400,7 @@ impl RectangleDrawData {
     pub fn new(ctx: &RenderContext, rectangles: &[TexturedRect]) -> Result<Self, RectangleError> {
         re_tracing::profile_function!();
 
-        let rectangle_renderer = ctx.get_renderer::<RectangleRenderer>();
+        let rectangle_renderer = ctx.renderer::<RectangleRenderer>();
 
         if rectangles.is_empty() {
             return Ok(RectangleDrawData {

crates/re_renderer/src/renderer/test_triangle.rs

@@ -22,7 +22,7 @@ impl DrawData for TestTriangleDrawData {
 
 impl TestTriangleDrawData {
     pub fn new(ctx: &RenderContext) -> Self {
-        let _ = ctx.get_renderer::<TestTriangle>(); // TODO(andreas): This should happen automatically.
+        let _ = ctx.renderer::<TestTriangle>(); // TODO(andreas): This line ensures that the renderer exists. Currently this needs to be done ahead of time, but should be fully automatic!
         TestTriangleDrawData {}
     }
 }