Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
perf(rendering): draw consecutive same-target layers in one render pass
Harsha Vardhan103da929ef20
diff --git a/crates/rendering/src/layers/captions.rs b/crates/rendering/src/layers/captions.rsindex 0c47bddd9..15af3ff47 100644--- a/crates/rendering/src/layers/captions.rs+++ b/crates/rendering/src/layers/captions.rs@@ -1046,7 +1046,7 @@ impl CaptionsLayer {self.active_layout}- pub fn render<'a>(&'a self, pass: &mut wgpu::RenderPass<'a>) {+ pub fn render(&self, pass: &mut wgpu::RenderPass<'_>) {if !self.has_caption {return;}diff --git a/crates/rendering/src/layers/keyboard.rs b/crates/rendering/src/layers/keyboard.rsindex a690adf3f..e690bfa3c 100644--- a/crates/rendering/src/layers/keyboard.rs+++ b/crates/rendering/src/layers/keyboard.rs@@ -568,7 +568,7 @@ impl KeyboardLayer {self.has_content}- pub fn render<'a>(&'a self, pass: &mut wgpu::RenderPass<'a>) {+ pub fn render(&self, pass: &mut wgpu::RenderPass<'_>) {if !self.has_content {return;}diff --git a/crates/rendering/src/layers/text.rs b/crates/rendering/src/layers/text.rsindex 36611496c..fbd161b40 100644--- a/crates/rendering/src/layers/text.rs+++ b/crates/rendering/src/layers/text.rs@@ -140,7 +140,7 @@ impl TextBackgroundResources {);}- fn render<'a>(&'a self, pass: &mut wgpu::RenderPass<'a>, index: usize) {+ fn render(&self, pass: &mut wgpu::RenderPass<'_>, index: usize) {pass.set_pipeline(&self.pipeline);pass.set_bind_group(0, &self.bind_groups[index], &[]);pass.draw(0..6, 0..1);@@ -759,7 +759,7 @@ impl TextLayer {}}- fn render_draw<'a>(&'a self, pass: &mut wgpu::RenderPass<'a>, index: usize) {+ fn render_draw(&self, pass: &mut wgpu::RenderPass<'_>, index: usize) {let draw = &self.draws[index];if let Some(background) = &self.background {for rect in draw.background.clone() {@@ -773,7 +773,7 @@ impl TextLayer {}}- pub fn render<'a>(&'a self, pass: &mut wgpu::RenderPass<'a>) {+ pub fn render(&self, pass: &mut wgpu::RenderPass<'_>) {if self.segmented_render {for index in 0..self.draws.len() {self.render_draw(pass, index);@@ -786,7 +786,7 @@ impl TextLayer {}}- pub fn render_track<'a>(&'a self, pass: &mut wgpu::RenderPass<'a>, track: u32) {+ pub fn render_track(&self, pass: &mut wgpu::RenderPass<'_>, track: u32) {if !self.segmented_render {return;}diff --git a/crates/rendering/src/lib.rs b/crates/rendering/src/lib.rsindex 8e95cd3b6..1943f4f70 100644--- a/crates/rendering/src/lib.rs+++ b/crates/rendering/src/lib.rs@@ -8299,24 +8299,6 @@ impl RendererLayers {render_display: bool,) -> Result<(), RenderingError> {self.validate_overlay_uniforms(uniforms)?;- macro_rules! render_pass {- ($view:expr, $load:expr) => {- encoder.begin_render_pass(&wgpu::RenderPassDescriptor {- label: Some("Render Pass"),- color_attachments: &[Some(wgpu::RenderPassColorAttachment {- view: $view,- resolve_target: None,- ops: wgpu::Operations {- load: $load,- store: wgpu::StoreOp::Store,- },- })],- depth_stencil_attachment: None,- timestamp_writes: None,- occlusion_query_set: None,- })- };- }if render_display {self.display.copy_to_texture(encoder);@@ -8325,6 +8307,13 @@ impl RendererLayers {self.camera_only.copy_to_texture(encoder);self.background.render_surface(encoder);+ let mut passes = LayerPasses {+ encoder,+ open: None,+ };+ let clear = wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT);+ let load = wgpu::LoadOp::Load;+let blur_key = (blur_result_cache_enabled() && self.background_blur.blur_amount > 0.0).then(|| self.background.static_generation()).flatten()@@ -8338,40 +8327,38 @@ impl RendererLayers {}});if let Some(cached) = blur_key.and_then(|key| self.background_blur.cached_result(key)) {- encoder.copy_texture_to_texture(+ passes.encoder().copy_texture_to_texture(cached.as_image_copy(),session.current_texture().as_image_copy(),cached.size(),);} else {- {- let mut pass = render_pass!(- session.current_texture_view(),- wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT)- );- self.background.render(&mut pass);- }+ self.background+ .render(passes.pass(session.current_texture_view(), clear));// Separable gaussian: horizontal into the spare texture, vertical// back into the current one, so the result ends up where it// started and no swap is needed.if self.background_blur.blur_amount > 0.0 {- {- let mut pass = render_pass!(session.other_texture_view(), wgpu::LoadOp::Load);- self.background_blur.render_h(- &mut pass,- device,- session.current_texture_view(),- );- }- let mut pass = render_pass!(session.current_texture_view(), wgpu::LoadOp::Load);- self.background_blur- .render_v(&mut pass, device, session.other_texture_view());+ self.background_blur.render_h(+ passes.pass(session.other_texture_view(), load),+ device,+ session.current_texture_view(),+ );+ self.background_blur.render_v(+ passes.pass(session.current_texture_view(), load),+ device,+ session.other_texture_view(),+ );}if let Some(key) = blur_key {- self.background_blur- .store_result(device, encoder, key, session.current_texture());+ self.background_blur.store_result(+ device,+ passes.encoder(),+ key,+ session.current_texture(),+ );}}@@ -8379,12 +8366,11 @@ impl RendererLayers {// backdrop; content layers grade themselves. The fullscreen triangle// overwrites every pixel, so the old target contents never load.if self.background_color_grade.is_active() {- let mut pass = render_pass!(- session.other_texture_view(),- wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT)+ self.background_color_grade.render(+ passes.pass(session.other_texture_view(), clear),+ device,+ session.current_texture_view(),);- self.background_color_grade- .render(&mut pass, device, session.current_texture_view());session.swap_textures();}@@ -8408,10 +8394,7 @@ impl RendererLayers {// stay flat on top. When inactive this is exactly the flat path.let camera3d_active = self.camera3d.is_active();if camera3d_active {- let _pass = render_pass!(- session.other_texture_view(),- wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT)- );+ passes.pass(session.other_texture_view(), clear);}macro_rules! content_view {() => {@@ -8424,67 +8407,66 @@ impl RendererLayers {}if should_render_screen && self.frame.has_content() {- let mut pass = render_pass!(content_view!(), wgpu::LoadOp::Load);- self.frame.render(&mut pass);+ self.frame.render(passes.pass(content_view!(), load));}if should_render_screen {- let mut pass = render_pass!(content_view!(), wgpu::LoadOp::Load);- self.display.render(&mut pass);+ self.display.render(passes.pass(content_view!(), load));}if should_render_cursor {- let mut pass = render_pass!(content_view!(), wgpu::LoadOp::Load);- self.click_ripple.render(&mut pass);- self.cursor.render(&mut pass);+ let pass = passes.pass(content_view!(), load);+ self.click_ripple.render(pass);+ self.cursor.render(pass);}// After the cursor, which really does disappear behind the notch on a// Mac, but before masks and text, which are editor annotations.if should_render_screen && self.notch.has_content() {- let mut pass = render_pass!(content_view!(), wgpu::LoadOp::Load);- self.notch.render(&mut pass);+ self.notch.render(passes.pass(content_view!(), load));}// Render camera-only layer when transitioning with CameraOnly modeif uniforms.scene.is_transitioning_camera_only() {- let mut pass = render_pass!(content_view!(), wgpu::LoadOp::Load);- self.camera_only.render(&mut pass);+ self.camera_only.render(passes.pass(content_view!(), load));}// Also render regular camera overlay during transitions when its opacity > 0if uniforms.scene.should_render_camera()&& uniforms.scene.regular_camera_transition_opacity() > 0.01{- let mut pass = render_pass!(content_view!(), wgpu::LoadOp::Load);- self.camera.render(&mut pass);+ self.camera.render(passes.pass(content_view!(), load));}if camera3d_active {- let mut pass = render_pass!(session.current_texture_view(), wgpu::LoadOp::Load);- self.camera3d- .render(&mut pass, device, session.other_texture_view());+ self.camera3d.render(+ passes.pass(session.current_texture_view(), load),+ device,+ session.other_texture_view(),+ );}// Focus blur over the composed frame (background and warped content// together), before the flat annotations.match self.camera3d.blur_kind() {Some(Camera3DBlurKind::Gaussian) => {- {- let mut pass = render_pass!(session.other_texture_view(), wgpu::LoadOp::Load);- self.camera3d- .render_blur_h(&mut pass, device, session.current_texture_view());- }- let mut pass = render_pass!(session.current_texture_view(), wgpu::LoadOp::Load);- self.camera3d- .render_blur_v(&mut pass, device, session.other_texture_view());+ self.camera3d.render_blur_h(+ passes.pass(session.other_texture_view(), load),+ device,+ session.current_texture_view(),+ );+ self.camera3d.render_blur_v(+ passes.pass(session.current_texture_view(), load),+ device,+ session.other_texture_view(),+ );}Some(Camera3DBlurKind::Bokeh) => {- {- let mut pass = render_pass!(session.other_texture_view(), wgpu::LoadOp::Load);- self.camera3d- .render_blur_v(&mut pass, device, session.current_texture_view());- }+ self.camera3d.render_blur_v(+ passes.pass(session.other_texture_view(), load),+ device,+ session.current_texture_view(),+ );session.swap_textures();}None => {}@@ -8493,19 +8475,22 @@ impl RendererLayers {if uniforms.project.overlay_order.is_empty() {if !uniforms.masks.is_empty() {for mask in &uniforms.masks {- self.mask.render(device, queue, session, encoder, mask);+ self.mask+ .render(device, queue, session, passes.encoder(), mask);}}if let Some(overlays) = &self.overlays {if render_display && overlays.images.has_content() {- let mut pass = render_pass!(session.current_texture_view(), wgpu::LoadOp::Load);- overlays.images.render(&mut pass);+ overlays+ .images+ .render(passes.pass(session.current_texture_view(), load));}if !uniforms.texts.is_empty() {- let mut pass = render_pass!(session.current_texture_view(), wgpu::LoadOp::Load);- overlays.text.render(&mut pass);+ overlays+ .text+ .render(passes.pass(session.current_texture_view(), load));}}} else if let Some(overlays) = &self.overlays {@@ -8517,20 +8502,23 @@ impl RendererLayers {.iter().filter(|mask| mask.track == overlay.track){- self.mask.render(device, queue, session, encoder, mask);+ self.mask+ .render(device, queue, session, passes.encoder(), mask);}}OverlayTrackKind::Imageif render_display && overlays.images.has_track(overlay.track) =>{- let mut pass =- render_pass!(session.current_texture_view(), wgpu::LoadOp::Load);- overlays.images.render_track(&mut pass, overlay.track);+ overlays.images.render_track(+ passes.pass(session.current_texture_view(), load),+ overlay.track,+ );}OverlayTrackKind::Text if overlays.text.has_track(overlay.track) => {- let mut pass =- render_pass!(session.current_texture_view(), wgpu::LoadOp::Load);- overlays.text.render_track(&mut pass, overlay.track);+ overlays.text.render_track(+ passes.pass(session.current_texture_view(), load),+ overlay.track,+ );}OverlayTrackKind::Text | OverlayTrackKind::Image => {}}@@ -8539,19 +8527,74 @@ impl RendererLayers {if let Some(overlays) = &self.overlays {if overlays.keyboard.has_content() {- let mut pass = render_pass!(session.current_texture_view(), wgpu::LoadOp::Load);- overlays.keyboard.render(&mut pass);+ overlays+ .keyboard+ .render(passes.pass(session.current_texture_view(), load));}if overlays.captions.has_content() {- let mut pass = render_pass!(session.current_texture_view(), wgpu::LoadOp::Load);- overlays.captions.render(&mut pass);+ overlays+ .captions+ .render(passes.pass(session.current_texture_view(), load));}}Ok(())}}+/// Lets consecutive layer draws into the same texture share one render pass.+/// Every pass boundary costs a store and reload of the whole attachment on+/// Apple's tile-based GPUs, and wgpu-core gives each pass its own native+/// command buffer, so a pass per layer multiplied both by the layer count.+struct LayerPasses<'a> {+ encoder: &'a mut wgpu::CommandEncoder,+ open: Option<(wgpu::TextureView, wgpu::RenderPass<'static>)>,+}++impl LayerPasses<'_> {+ fn pass(+ &mut self,+ view: &wgpu::TextureView,+ load: wgpu::LoadOp<wgpu::Color>,+ ) -> &mut wgpu::RenderPass<'static> {+ let continues_open_pass = matches!(load, wgpu::LoadOp::Load)+ && self+ .open+ .as_ref()+ .is_some_and(|(open_view, _)| open_view == view);+ if !continues_open_pass {+ self.open = None;+ let pass = self+ .encoder+ .begin_render_pass(&wgpu::RenderPassDescriptor {+ label: Some("Render Pass"),+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {+ view,+ resolve_target: None,+ ops: wgpu::Operations {+ load,+ store: wgpu::StoreOp::Store,+ },+ })],+ depth_stencil_attachment: None,+ timestamp_writes: None,+ occlusion_query_set: None,+ })+ .forget_lifetime();+ self.open = Some((view.clone(), pass));+ }+ let Some((_, pass)) = &mut self.open else {+ unreachable!("a render pass was opened above")+ };+ pass+ }++ fn encoder(&mut self) -> &mut wgpu::CommandEncoder {+ self.open = None;+ self.encoder+ }+}+async fn produce_frame_with_timings(constants: &RenderVideoConstants,segment_frames: DecodedSegmentFrames,