Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 mode
if 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 > 0
if 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::Image
if 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,