Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

perf(rendering): reuse the blurred static background in the editor and exports

Harsha Vardhan27a46235c910
diff --git a/crates/render-farm/src/main.rs b/crates/render-farm/src/main.rs
index 82ea72462..aeb9effed 100644
--- a/crates/render-farm/src/main.rs
+++ b/crates/render-farm/src/main.rs
@@ -124,7 +124,6 @@ async fn handle(op: Op) -> Result<Value> {
}
fn main() -> Result<()> {
- cap_rendering::enable_blur_result_cache();
tracing_subscriber::fmt()
.with_writer(std::io::stderr)
.with_env_filter(
diff --git a/crates/rendering/src/frame_pipeline.rs b/crates/rendering/src/frame_pipeline.rs
index 0c8461a52..e2681b06d 100644
--- a/crates/rendering/src/frame_pipeline.rs
+++ b/crates/rendering/src/frame_pipeline.rs
@@ -1944,17 +1944,13 @@ pub struct RenderSession {
export_deadlines: bool,
}
-/// The blur result cache copies into session textures, so only render hosts
-/// that enable it need them to be copy destinations.
+/// The blurred-background cache copies its result into the current session
+/// texture.
fn session_texture_usage() -> wgpu::TextureUsages {
- let usage = wgpu::TextureUsages::TEXTURE_BINDING
+ wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::RENDER_ATTACHMENT
- | wgpu::TextureUsages::COPY_SRC;
- if crate::blur_result_cache_enabled() {
- usage | wgpu::TextureUsages::COPY_DST
- } else {
- usage
- }
+ | wgpu::TextureUsages::COPY_SRC
+ | wgpu::TextureUsages::COPY_DST
}
impl RenderSession {
diff --git a/crates/rendering/src/layers/blur.rs b/crates/rendering/src/layers/blur.rs
index d3266a0c2..e294ecffa 100644
--- a/crates/rendering/src/layers/blur.rs
+++ b/crates/rendering/src/layers/blur.rs
@@ -63,6 +63,15 @@ impl BlurLayer {
.map(|(_, texture)| texture)
}
+ pub fn clear_result(&mut self) {
+ self.result = None;
+ }
+
+ #[cfg(test)]
+ pub fn has_cached_result(&self) -> bool {
+ self.result.is_some()
+ }
+
pub fn store_result(
&mut self,
device: &wgpu::Device,
diff --git a/crates/rendering/src/lib.rs b/crates/rendering/src/lib.rs
index 1943f4f70..146e47650 100644
--- a/crates/rendering/src/lib.rs
+++ b/crates/rendering/src/lib.rs
@@ -1263,19 +1263,6 @@ pub mod loop_stats {
}
}
-/// A blurred static background is identical on every frame. Render hosts
-/// reuse the first frame's result; editor and desktop exports keep blurring
-/// every frame until this has been verified there.
-static BLUR_RESULT_CACHE: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
-
-pub fn enable_blur_result_cache() {
- BLUR_RESULT_CACHE.store(true, std::sync::atomic::Ordering::Relaxed);
-}
-
-fn blur_result_cache_enabled() -> bool {
- BLUR_RESULT_CACHE.load(std::sync::atomic::Ordering::Relaxed)
-}
-
/// Layer pipelines take ~0.25-0.5 s to build per render. A process that
/// renders many ranges of the same project (a render-farm engine) can set a
/// key naming that project; successful renders then hand their layers to the
@@ -7995,9 +7982,7 @@ impl RendererLayers {
)
.await?;
- if uniforms.project.background.blur > 0.0 {
- self.background_blur.prepare(&constants.queue, uniforms);
- }
+ self.background_blur.prepare(&constants.queue, uniforms);
self.background_color_grade
.prepare(&constants.queue, uniforms);
@@ -8151,9 +8136,7 @@ impl RendererLayers {
timings.background_prepare_duration = start.elapsed();
let start = Instant::now();
- if uniforms.project.background.blur > 0.0 {
- self.background_blur.prepare(&constants.queue, uniforms);
- }
+ self.background_blur.prepare(&constants.queue, uniforms);
self.background_color_grade
.prepare(&constants.queue, uniforms);
timings.background_blur_prepare_duration = start.elapsed();
@@ -8314,7 +8297,7 @@ impl RendererLayers {
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)
+ let blur_key = (self.background_blur.blur_amount > 0.0)
.then(|| self.background.static_generation())
.flatten()
.map(|background_generation| {
@@ -8326,6 +8309,9 @@ impl RendererLayers {
texture_size: (size.width, size.height),
}
});
+ if blur_key.is_none() {
+ self.background_blur.clear_result();
+ }
if let Some(cached) = blur_key.and_then(|key| self.background_blur.cached_result(key)) {
passes.encoder().copy_texture_to_texture(
cached.as_image_copy(),
diff --git a/crates/rendering/src/overlay_layers/native_tests.rs b/crates/rendering/src/overlay_layers/native_tests.rs
index db1695c6b..899f08b44 100644
--- a/crates/rendering/src/overlay_layers/native_tests.rs
+++ b/crates/rendering/src/overlay_layers/native_tests.rs
@@ -366,3 +366,65 @@ async fn restricted_late_uniforms_fail_before_prepare_or_direct_render_work() {
}
assert_eq!(std::fs::read_dir(directory.path()).unwrap().count(), 0);
}
+
+#[tokio::test]
+async fn cached_background_blur_matches_a_fresh_blur_and_follows_edits() {
+ let directory = tempfile::tempdir().unwrap();
+ let constants = constants(directory.path()).await;
+ let blurred = |blur: f64, from: [u16; 3]| {
+ let mut project = project();
+ project.background.source = serde_json::from_value(serde_json::json!({
+ "type": "gradient", "from": from, "to": [16, 32, 200], "angle": 90
+ }))
+ .unwrap();
+ project.background.blur = blur;
+ project
+ };
+ let fresh_layers = || {
+ RendererLayers::new_with_options(
+ &constants.device,
+ &constants.queue,
+ constants.is_software_adapter,
+ )
+ };
+ let mut cached = fresh_layers();
+
+ let heavy = blurred(40.0, [255, 96, 32]);
+ render(&constants, &heavy, &mut cached, 0).await;
+ let reused = pixels(&render(&constants, &heavy, &mut cached, 1).await.0);
+ let expected = pixels(&render(&constants, &heavy, &mut fresh_layers(), 1).await.0);
+ assert_eq!(reused, expected);
+
+ let light = blurred(10.0, [255, 96, 32]);
+ let after_blur_edit = pixels(&render(&constants, &light, &mut cached, 2).await.0);
+ assert_ne!(after_blur_edit, reused);
+ assert_eq!(
+ after_blur_edit,
+ pixels(&render(&constants, &light, &mut fresh_layers(), 2).await.0)
+ );
+
+ let recolored = blurred(10.0, [32, 200, 96]);
+ let after_background_edit = pixels(&render(&constants, &recolored, &mut cached, 3).await.0);
+ assert_ne!(after_background_edit, after_blur_edit);
+ assert_eq!(
+ after_background_edit,
+ pixels(
+ &render(&constants, &recolored, &mut fresh_layers(), 3)
+ .await
+ .0
+ )
+ );
+
+ assert!(cached.background_blur.has_cached_result());
+ let unblurred = blurred(0.0, [32, 200, 96]);
+ let after_blur_off = pixels(&render(&constants, &unblurred, &mut cached, 6).await.0);
+ assert_eq!(
+ after_blur_off,
+ pixels(
+ &render(&constants, &unblurred, &mut fresh_layers(), 6)
+ .await
+ .0
+ )
+ );
+ assert!(!cached.background_blur.has_cached_result());
+}