egui-wgpu renderer renaming

- `RenderPass` -> `Renderer`
- `RenderPass::execute` -> `Renderer::render`
- `RenderPass::execute_with_renderpass` -> `Renderer::render_onto_renderpass`
- reexport `Renderer` in `lib.rs`

Author: luiswirth

crates/egui-wgpu/CHANGELOG.md

@@ -3,6 +3,10 @@ All notable changes to the `egui-wgpu` integration will be noted in this file.
 
 
 ## Unreleased
+* Rename `RenderPass` to `Renderer`
+* Rename `RenderPass::execute` to `RenderPass::render`
+* Rename `RenderPass::execute_with_renderpass` to `Renderer::render_onto_renderpass`
+* Reexport `Renderer`
 
 
 ## 0.19.0 - 2022-08-20

crates/egui-wgpu/src/lib.rs

@@ -11,6 +11,7 @@ pub use wgpu;
 /// Low-level painting of [`egui`] on [`wgpu`].
 pub mod renderer;
 pub use renderer::CallbackFn;
+pub use renderer::Renderer;
 
 /// Module for painting [`egui`] with [`wgpu`] on [`winit`].
 #[cfg(feature = "winit")]

crates/egui-wgpu/src/renderer.rs

@@ -118,9 +118,9 @@ struct SizedBuffer {
     size: usize,
 }
 
-/// Render pass to render a egui based GUI.
-pub struct RenderPass {
-    render_pipeline: wgpu::RenderPipeline,
+/// Renderer for a egui based GUI.
+pub struct Renderer {
+    pipeline: wgpu::RenderPipeline,
     depth_texture: Option<(wgpu::Texture, wgpu::TextureView)>,
     index_buffers: Vec<SizedBuffer>,
     vertex_buffers: Vec<SizedBuffer>,
@@ -137,8 +137,8 @@ pub struct RenderPass {
     pub paint_callback_resources: TypeMap,
 }
 
-impl RenderPass {
-    /// Creates a new render pass to render a egui UI.
+impl Renderer {
+    /// Creates a renderer for a egui UI.
     ///
     /// If the format passed is not a *Srgb format, the shader will automatically convert to `sRGB` colors in the shader.
     pub fn new(
@@ -231,7 +231,7 @@ impl RenderPass {
             bias: wgpu::DepthBiasState::default(),
         });
 
-        let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
             label: Some("egui_pipeline"),
             layout: Some(&pipeline_layout),
             vertex: wgpu::VertexState {
@@ -290,7 +290,7 @@ impl RenderPass {
         });
 
         Self {
-            render_pipeline,
+            pipeline,
             vertex_buffers: Vec::with_capacity(64),
             index_buffers: Vec::with_capacity(64),
             uniform_buffer,
@@ -323,8 +323,8 @@ impl RenderPass {
         self.depth_texture = Some((texture, view));
     }
 
-    /// Executes the egui render pass.
-    pub fn execute(
+    /// Executes the renderer on it's own render pass.
+    pub fn render(
         &self,
         encoder: &mut wgpu::CommandEncoder,
         color_attachment: &wgpu::TextureView,
@@ -349,7 +349,7 @@ impl RenderPass {
             }
         });
 
-        let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+        let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                 view: color_attachment,
                 resolve_target: None,
@@ -359,26 +359,23 @@ impl RenderPass {
                 },
             })],
             depth_stencil_attachment,
-            label: Some("egui main render pass"),
+            label: Some("egui_render_pass"),
         });
-        rpass.push_debug_group("egui_pass");
 
-        self.execute_with_renderpass(&mut rpass, paint_jobs, screen_descriptor);
-
-        rpass.pop_debug_group();
+        self.render_onto_renderpass(&mut render_pass, paint_jobs, screen_descriptor);
     }
 
-    /// Executes the egui render pass onto an existing wgpu renderpass.
-    pub fn execute_with_renderpass<'rpass>(
-        &'rpass self,
-        rpass: &mut wgpu::RenderPass<'rpass>,
+    /// Executes the egui renderer onto an existing wgpu renderpass.
+    pub fn render_onto_renderpass<'rp>(
+        &'rp self,
+        render_pass: &mut wgpu::RenderPass<'rp>,
         paint_jobs: &[egui::epaint::ClippedPrimitive],
         screen_descriptor: &ScreenDescriptor,
     ) {
         let pixels_per_point = screen_descriptor.pixels_per_point;
         let size_in_pixels = screen_descriptor.size_in_pixels;
 
-        // Whether or not we need to reset the renderpass state because a paint callback has just
+        // Whether or not we need to reset the render pass because a paint callback has just
         // run.
         let mut needs_reset = true;
 
@@ -391,16 +388,16 @@ impl RenderPass {
         } in paint_jobs
         {
             if needs_reset {
-                rpass.set_viewport(
+                render_pass.set_viewport(
                     0.0,
                     0.0,
                     size_in_pixels[0] as f32,
                     size_in_pixels[1] as f32,
                     0.0,
                     1.0,
                 );
-                rpass.set_pipeline(&self.render_pipeline);
-                rpass.set_bind_group(0, &self.uniform_bind_group, &[]);
+                render_pass.set_pipeline(&self.pipeline);
+                render_pass.set_bind_group(0, &self.uniform_bind_group, &[]);
                 needs_reset = false;
             }
 
@@ -417,7 +414,7 @@ impl RenderPass {
                     continue;
                 }
 
-                rpass.set_scissor_rect(rect.x, rect.y, rect.width, rect.height);
+                render_pass.set_scissor_rect(rect.x, rect.y, rect.width, rect.height);
             }
 
             match primitive {
@@ -426,13 +423,13 @@ impl RenderPass {
                     let vertex_buffer = vertex_buffers.next().unwrap();
 
                     if let Some((_texture, bind_group)) = self.textures.get(&mesh.texture_id) {
-                        rpass.set_bind_group(1, bind_group, &[]);
-                        rpass.set_index_buffer(
+                        render_pass.set_bind_group(1, bind_group, &[]);
+                        render_pass.set_index_buffer(
                             index_buffer.buffer.slice(..),
                             wgpu::IndexFormat::Uint32,
                         );
-                        rpass.set_vertex_buffer(0, vertex_buffer.buffer.slice(..));
-                        rpass.draw_indexed(0..mesh.indices.len() as u32, 0, 0..1);
+                        render_pass.set_vertex_buffer(0, vertex_buffer.buffer.slice(..));
+                        render_pass.draw_indexed(0..mesh.indices.len() as u32, 0, 0..1);
                     } else {
                         tracing::warn!("Missing texture: {:?}", mesh.texture_id);
                     }
@@ -461,7 +458,7 @@ impl RenderPass {
                             let rect_max_x = rect_max_x.round();
                             let rect_max_y = rect_max_y.round();
 
-                            rpass.set_viewport(
+                            render_pass.set_viewport(
                                 rect_min_x,
                                 rect_min_y,
                                 rect_max_x - rect_min_x,
@@ -478,18 +475,18 @@ impl RenderPass {
                                 pixels_per_point,
                                 screen_size_px: size_in_pixels,
                             },
-                            rpass,
+                            render_pass,
                             &self.paint_callback_resources,
                         );
                     }
                 }
             }
         }
 
-        rpass.set_scissor_rect(0, 0, size_in_pixels[0], size_in_pixels[1]);
+        render_pass.set_scissor_rect(0, 0, size_in_pixels[0], size_in_pixels[1]);
     }
 
-    /// Should be called before `execute()`.
+    /// Should be called before `render()`.
     pub fn update_texture(
         &mut self,
         device: &wgpu::Device,
@@ -768,8 +765,8 @@ impl RenderPass {
         *user_texture_binding = bind_group;
     }
 
-    /// Uploads the uniform, vertex and index data used by the render pass.
-    /// Should be called before `execute()`.
+    /// Uploads the uniform, vertex and index data used by the renderer.
+    /// Should be called before `render()`.
     pub fn update_buffers(
         &mut self,
         device: &wgpu::Device,
@@ -922,7 +919,7 @@ impl ScissorRect {
 }
 
 #[test]
-fn render_pass_impl_send_sync() {
+fn renderer_impl_send_sync() {
     fn assert_send_sync<T: Send + Sync>() {}
-    assert_send_sync::<RenderPass>();
+    assert_send_sync::<Renderer>();
 }

crates/egui-wgpu/src/winit.rs

@@ -4,7 +4,7 @@ use egui::mutex::RwLock;
 use tracing::error;
 use wgpu::{Adapter, Instance, Surface};
 
-use crate::renderer;
+use crate::{renderer, Renderer};
 
 /// Access to the render state for egui, which can be useful in combination with
 /// [`egui::PaintCallback`]s for custom rendering using WGPU.
@@ -13,7 +13,7 @@ pub struct RenderState {
     pub device: Arc<wgpu::Device>,
     pub queue: Arc<wgpu::Queue>,
     pub target_format: wgpu::TextureFormat,
-    pub egui_rpass: Arc<RwLock<renderer::RenderPass>>,
+    pub renderer: Arc<RwLock<Renderer>>,
 }
 
 struct SurfaceState {
@@ -90,14 +90,13 @@ impl<'a> Painter<'a> {
         let (device, queue) =
             pollster::block_on(adapter.request_device(&self.device_descriptor, None)).unwrap();
 
-        let rpass =
-            renderer::RenderPass::new(&device, target_format, self.msaa_samples, self.depth_bits);
+        let renderer = Renderer::new(&device, target_format, self.msaa_samples, self.depth_bits);
 
         RenderState {
             device: Arc::new(device),
             queue: Arc::new(queue),
             target_format,
-            egui_rpass: Arc::new(RwLock::new(rpass)),
+            renderer: Arc::new(RwLock::new(renderer)),
         }
     }
 
@@ -151,7 +150,7 @@ impl<'a> Painter<'a> {
         surface_state.height = height_in_pixels;
 
         if self.depth_bits > 0 {
-            render_state.egui_rpass.write().update_depth_texture(
+            render_state.renderer.write().update_depth_texture(
                 &render_state.device,
                 width_in_pixels,
                 height_in_pixels,
@@ -272,12 +271,17 @@ impl<'a> Painter<'a> {
         };
 
         {
-            let mut rpass = render_state.egui_rpass.write();
+            let mut renderer = render_state.renderer.write();
             for (id, image_delta) in &textures_delta.set {
-                rpass.update_texture(&render_state.device, &render_state.queue, *id, image_delta);
+                renderer.update_texture(
+                    &render_state.device,
+                    &render_state.queue,
+                    *id,
+                    image_delta,
+                );
             }
 
-            rpass.update_buffers(
+            renderer.update_buffers(
                 &render_state.device,
                 &render_state.queue,
                 clipped_primitives,
@@ -286,7 +290,7 @@ impl<'a> Painter<'a> {
         }
 
         // Record all render passes.
-        render_state.egui_rpass.read().execute(
+        render_state.renderer.read().render(
             &mut encoder,
             &output_view,
             clipped_primitives,
@@ -300,9 +304,9 @@ impl<'a> Painter<'a> {
         );
 
         {
-            let mut rpass = render_state.egui_rpass.write();
+            let mut renderer = render_state.renderer.write();
             for id in &textures_delta.free {
-                rpass.free_texture(id);
+                renderer.free_texture(id);
             }
         }
 

crates/egui_demo_app/src/apps/custom3d_wgpu.rs

@@ -82,7 +82,7 @@ impl Custom3d {
         // instead of storing the pipeline in our `Custom3D` struct, we insert it into the
         // `paint_callback_resources` type map, which is stored alongside the render pass.
         wgpu_render_state
-            .egui_rpass
+            .renderer
             .write()
             .paint_callback_resources
             .insert(TriangleRenderResources {
@@ -142,9 +142,9 @@ impl Custom3d {
                 let resources: &TriangleRenderResources = paint_callback_resources.get().unwrap();
                 resources.prepare(device, queue, angle);
             })
-            .paint(move |_info, rpass, paint_callback_resources| {
+            .paint(move |_info, render_pass, paint_callback_resources| {
                 let resources: &TriangleRenderResources = paint_callback_resources.get().unwrap();
-                resources.paint(rpass);
+                resources.paint(render_pass);
             });
 
         let callback = egui::PaintCallback {
@@ -168,10 +168,10 @@ impl TriangleRenderResources {
         queue.write_buffer(&self.uniform_buffer, 0, bytemuck::cast_slice(&[angle]));
     }
 
-    fn paint<'rpass>(&'rpass self, rpass: &mut wgpu::RenderPass<'rpass>) {
+    fn paint<'rp>(&'rp self, render_pass: &mut wgpu::RenderPass<'rp>) {
         // Draw our triangle!
-        rpass.set_pipeline(&self.pipeline);
-        rpass.set_bind_group(0, &self.bind_group, &[]);
-        rpass.draw(0..3, 0..1);
+        render_pass.set_pipeline(&self.pipeline);
+        render_pass.set_bind_group(0, &self.bind_group, &[]);
+        render_pass.draw(0..3, 0..1);
     }
 }