Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

test(rendering): check shared render passes against one pass per layer

Harsha Vardhane0b5fe2dbf07
diff --git a/crates/rendering/src/lib.rs b/crates/rendering/src/lib.rs
index 146e47650..6be9e0815 100644
--- a/crates/rendering/src/lib.rs
+++ b/crates/rendering/src/lib.rs
@@ -7663,6 +7663,8 @@ pub struct RendererLayers {
camera_blur_init_failed: bool,
camera_blur_unavailable: bool,
realtime_camera_effects: bool,
+ #[cfg(test)]
+ split_layer_passes: bool,
}
fn join_layer<T>(handle: std::thread::ScopedJoinHandle<'_, T>) -> T {
@@ -7786,6 +7788,8 @@ impl RendererLayers {
camera_blur_init_failed: false,
camera_blur_unavailable: false,
realtime_camera_effects: false,
+ #[cfg(test)]
+ split_layer_passes: false,
}
});
layers_phase.finish("returned");
@@ -8293,6 +8297,8 @@ impl RendererLayers {
let mut passes = LayerPasses {
encoder,
open: None,
+ #[cfg(test)]
+ split: self.split_layer_passes,
};
let clear = wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT);
let load = wgpu::LoadOp::Load;
@@ -8532,9 +8538,14 @@ impl RendererLayers {
/// 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.
+/// Because consecutive layers share one pass, a layer that changes dynamic
+/// pass state (scissor, viewport, blend constant, stencil reference) must
+/// restore it before returning.
struct LayerPasses<'a> {
encoder: &'a mut wgpu::CommandEncoder,
open: Option<(wgpu::TextureView, wgpu::RenderPass<'static>)>,
+ #[cfg(test)]
+ split: bool,
}
impl LayerPasses<'_> {
@@ -8544,6 +8555,7 @@ impl LayerPasses<'_> {
load: wgpu::LoadOp<wgpu::Color>,
) -> &mut wgpu::RenderPass<'static> {
let continues_open_pass = matches!(load, wgpu::LoadOp::Load)
+ && !self.splits_every_layer()
&& self
.open
.as_ref()
@@ -8579,6 +8591,16 @@ impl LayerPasses<'_> {
self.open = None;
self.encoder
}
+
+ #[cfg(test)]
+ fn splits_every_layer(&self) -> bool {
+ self.split
+ }
+
+ #[cfg(not(test))]
+ fn splits_every_layer(&self) -> bool {
+ false
+ }
}
async fn produce_frame_with_timings(
diff --git a/crates/rendering/src/overlay_layers/native_tests.rs b/crates/rendering/src/overlay_layers/native_tests.rs
index 899f08b44..02153e989 100644
--- a/crates/rendering/src/overlay_layers/native_tests.rs
+++ b/crates/rendering/src/overlay_layers/native_tests.rs
@@ -1,5 +1,5 @@
use crate::{
- CursorEvents, DecodedFrame, DecodedSegmentFrames, FrameLayout, FrameRenderer,
+ CursorEvents, DecodedFrame, DecodedSegmentFrames, FrameLayout, FrameRenderer, LayerPasses,
ProjectConfiguration, ProjectUniforms, RecordingMeta, RenderOptions, RenderVideoConstants,
RenderedFrame, RendererLayers, RenderingError, XY, ZoomTransformTimeline,
frame_pipeline::{RenderSession, finish_encoder_timed, flush_pending_readback},
@@ -10,6 +10,10 @@ const WIDTH: u32 = 160;
const HEIGHT: u32 = 120;
async fn constants(path: &Path) -> RenderVideoConstants {
+ constants_with_camera(path, None).await
+}
+
+async fn constants_with_camera(path: &Path, camera_size: Option<XY<u32>>) -> RenderVideoConstants {
let mut metadata: RecordingMeta = serde_json::from_value(serde_json::json!({
"pretty_name": "overlay boundary",
"display": {"path": "unused.mp4", "fps": 30},
@@ -21,7 +25,7 @@ async fn constants(path: &Path) -> RenderVideoConstants {
let constants = RenderVideoConstants::new_with_options(
RenderOptions {
screen_size: XY::new(WIDTH, HEIGHT),
- camera_size: None,
+ camera_size,
preserve_screen_alpha: false,
},
metadata,
@@ -82,6 +86,16 @@ fn uniforms(
constants: &RenderVideoConstants,
project: &ProjectConfiguration,
frame: u32,
+) -> ProjectUniforms {
+ uniforms_for(constants, project, frame, XY::new(320, 240), &frames())
+}
+
+fn uniforms_for(
+ constants: &RenderVideoConstants,
+ project: &ProjectConfiguration,
+ frame: u32,
+ resolution: XY<u32>,
+ segment_frames: &DecodedSegmentFrames,
) -> ProjectUniforms {
let cursor = CursorEvents::default();
let zoom =
@@ -91,9 +105,9 @@ fn uniforms(
project,
frame,
30,
- XY::new(320, 240),
+ resolution,
&cursor,
- &frames(),
+ segment_frames,
3.0,
&zoom,
)
@@ -114,10 +128,35 @@ async fn render(
layers: &mut RendererLayers,
frame: u32,
) -> (RenderedFrame, FrameLayout) {
- let uniforms = uniforms(constants, project, frame);
+ render_for(
+ constants,
+ project,
+ layers,
+ frame,
+ XY::new(320, 240),
+ frames(),
+ )
+ .await
+}
+
+async fn render_for(
+ constants: &RenderVideoConstants,
+ project: &ProjectConfiguration,
+ layers: &mut RendererLayers,
+ frame: u32,
+ resolution: XY<u32>,
+ segment_frames: DecodedSegmentFrames,
+) -> (RenderedFrame, FrameLayout) {
+ let uniforms = uniforms_for(constants, project, frame, resolution, &segment_frames);
let layout = uniforms.frame_layout();
let output = FrameRenderer::new(constants)
- .render_immediate(frames(), uniforms, &CursorEvents::default(), true, layers)
+ .render_immediate(
+ segment_frames,
+ uniforms,
+ &CursorEvents::default(),
+ true,
+ layers,
+ )
.await
.expect("Native overlay frame must render");
(output, layout)
@@ -415,6 +454,38 @@ async fn cached_background_blur_matches_a_fresh_blur_and_follows_edits() {
)
);
+ let smaller = XY::new(200, 150);
+ let resized = pixels(
+ &render_for(&constants, &recolored, &mut cached, 4, smaller, frames())
+ .await
+ .0,
+ );
+ assert_ne!(resized.len(), after_background_edit.len());
+ assert_eq!(
+ resized,
+ pixels(
+ &render_for(
+ &constants,
+ &recolored,
+ &mut fresh_layers(),
+ 4,
+ smaller,
+ frames()
+ )
+ .await
+ .0
+ )
+ );
+ let restored = pixels(&render(&constants, &recolored, &mut cached, 5).await.0);
+ assert_eq!(
+ restored,
+ pixels(
+ &render(&constants, &recolored, &mut fresh_layers(), 5)
+ .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);
@@ -428,3 +499,276 @@ async fn cached_background_blur_matches_a_fresh_blur_and_follows_edits() {
);
assert!(!cached.background_blur.has_cached_result());
}
+
+fn every_overlay() -> ProjectConfiguration {
+ let mut project = with_overlay("image", "overlay.png");
+ for kind in ["text", "captions", "keyboard"] {
+ let overlay = with_overlay(kind, "");
+ let segments = overlay.timeline.unwrap();
+ let timeline = project.timeline.as_mut().unwrap();
+ timeline.text_segments.extend(segments.text_segments);
+ timeline.caption_segments.extend(segments.caption_segments);
+ timeline
+ .keyboard_segments
+ .extend(segments.keyboard_segments);
+ project.captions = project.captions.or(overlay.captions);
+ project.keyboard = project.keyboard.or(overlay.keyboard);
+ }
+ project
+}
+
+type LayerDraw<'a> = &'a dyn Fn(&mut wgpu::RenderPass<'_>);
+
+async fn draw_in_one_pass(
+ constants: &RenderVideoConstants,
+ uniforms: &ProjectUniforms,
+ draws: &[LayerDraw<'_>],
+) -> Vec<u8> {
+ let mut session = RenderSession::new(
+ &constants.device,
+ uniforms.output_size.0,
+ uniforms.output_size.1,
+ );
+ let mut encoder = constants.device.create_command_encoder(&Default::default());
+ {
+ let mut passes = LayerPasses {
+ encoder: &mut encoder,
+ open: None,
+ split: false,
+ };
+ passes.pass(
+ session.current_texture_view(),
+ wgpu::LoadOp::Clear(wgpu::Color::BLACK),
+ );
+ for draw in draws {
+ draw(passes.pass(session.current_texture_view(), wgpu::LoadOp::Load));
+ }
+ }
+ read_session(constants, &mut session, uniforms, encoder).await
+}
+
+#[tokio::test]
+async fn scissored_overlays_leave_the_full_target_to_the_next_layer_in_their_pass() {
+ let directory = tempfile::tempdir().unwrap();
+ let constants = constants(directory.path()).await;
+ image::RgbaImage::from_pixel(16, 16, image::Rgba([255, 16, 32, 255]))
+ .save(directory.path().join("overlay.png"))
+ .unwrap();
+ let project = every_overlay();
+ let uniforms = uniforms(&constants, &project, 30);
+ let mut layers = RendererLayers::new(&constants.device, &constants.queue);
+ layers
+ .prepare(
+ &constants,
+ &uniforms,
+ &frames(),
+ &CursorEvents::default(),
+ true,
+ )
+ .await
+ .unwrap();
+ let overlays = layers.overlays.as_ref().unwrap();
+ assert!(overlays.images.has_content());
+ assert!(overlays.keyboard.has_content());
+ assert!(overlays.captions.has_content());
+
+ let image = |pass: &mut wgpu::RenderPass<'_>| overlays.images.render(pass);
+ let keyboard = |pass: &mut wgpu::RenderPass<'_>| overlays.keyboard.render(pass);
+ let captions = |pass: &mut wgpu::RenderPass<'_>| overlays.captions.render(pass);
+ let base = draw_in_one_pass(&constants, &uniforms, &[]).await;
+ let image_only = draw_in_one_pass(&constants, &uniforms, &[&image]).await;
+ let scissored: [(&str, LayerDraw<'_>); 2] = [("keyboard", &keyboard), ("captions", &captions)];
+ for (name, scissored) in scissored {
+ let alone = draw_in_one_pass(&constants, &uniforms, &[scissored]).await;
+ let shared = draw_in_one_pass(&constants, &uniforms, &[scissored, &image]).await;
+ let mut image_pixels_outside = 0;
+ for (((base, alone), image_only), shared) in base
+ .chunks_exact(4)
+ .zip(alone.chunks_exact(4))
+ .zip(image_only.chunks_exact(4))
+ .zip(shared.chunks_exact(4))
+ {
+ if alone == base {
+ assert_eq!(
+ shared, image_only,
+ "{name} left its scissor on the pass it shares with the next layer"
+ );
+ image_pixels_outside += usize::from(image_only != base);
+ }
+ }
+ assert!(
+ image_pixels_outside > 0,
+ "the image overlay must draw outside the {name} rect"
+ );
+ }
+}
+
+async fn render_layer_passes(
+ constants: &RenderVideoConstants,
+ project: &ProjectConfiguration,
+ split: bool,
+ segment_frames: DecodedSegmentFrames,
+) -> Vec<u8> {
+ let mut layers = RendererLayers::new_with_options(
+ &constants.device,
+ &constants.queue,
+ constants.is_software_adapter,
+ );
+ layers.split_layer_passes = split;
+ pixels(
+ &render_for(
+ constants,
+ project,
+ &mut layers,
+ 30,
+ XY::new(320, 240),
+ segment_frames,
+ )
+ .await
+ .0,
+ )
+}
+
+fn blurred_background(project: &mut ProjectConfiguration) {
+ project.background.source = serde_json::from_value(serde_json::json!({
+ "type": "gradient", "from": [255, 96, 32], "to": [16, 32, 200], "angle": 90
+ }))
+ .unwrap();
+ project.background.blur = 30.0;
+ project.background.padding = 12.0;
+}
+
+fn masks(project: &mut ProjectConfiguration) {
+ project.timeline.as_mut().unwrap().mask_segments = serde_json::from_value(serde_json::json!([
+ {
+ "start": 0.0, "end": 3.0, "maskType": "sensitive", "fadeDuration": 0.0,
+ "center": {"x": 0.3, "y": 0.35}, "size": {"x": 0.3, "y": 0.3}, "pixelation": 12.0
+ },
+ {
+ "start": 0.0, "end": 3.0, "maskType": "highlight", "fadeDuration": 0.0,
+ "center": {"x": 0.7, "y": 0.6}, "size": {"x": 0.25, "y": 0.25}, "darkness": 0.6
+ }
+ ]))
+ .unwrap();
+}
+
+fn camera3d(project: &mut ProjectConfiguration, bokeh: bool) {
+ project.timeline.as_mut().unwrap().camera3d_segments =
+ serde_json::from_value(serde_json::json!([{
+ "start": 0.0, "end": 3.0, "transitionIn": 0.0, "transitionOut": 0.0,
+ "properties": {"tiltX": 14.0, "tiltY": -10.0, "rotateY": 8.0},
+ "blur": {"mode": "radial", "strength": 10.0, "bokeh": bokeh}
+ }]))
+ .unwrap();
+}
+
+fn color_grade(project: &mut ProjectConfiguration) {
+ project.color_correction.screen = serde_json::from_value(serde_json::json!({
+ "preset": "custom", "intensity": 1.0, "saturation": -0.6, "contrast": 0.4, "vignette": 0.5
+ }))
+ .unwrap();
+}
+
+fn device_frame(project: &mut ProjectConfiguration) {
+ project.background.padding = 12.0;
+ project.background.frame = Some(cap_project::FrameConfiguration {
+ style: cap_project::FrameStyle::MacOS,
+ ..Default::default()
+ });
+ project.background.notch = Some(cap_project::NotchConfiguration {
+ enabled: true,
+ ..Default::default()
+ });
+}
+
+// The notch tests' escape hatch: windows-2022 WARP stopped compositing these passes correctly.
+fn adapter_cannot_composite(constants: &RenderVideoConstants) -> bool {
+ let name = constants._adapter.get_info().name;
+ name.contains("Basic Render Driver") || name.to_lowercase().contains("warp")
+}
+
+#[tokio::test]
+async fn layers_sharing_a_pass_render_like_one_pass_per_layer() {
+ let directory = tempfile::tempdir().unwrap();
+ let constants = constants(directory.path()).await;
+ image::RgbaImage::from_pixel(16, 16, image::Rgba([255, 16, 32, 255]))
+ .save(directory.path().join("overlay.png"))
+ .unwrap();
+ type ProjectEdit = fn(&mut ProjectConfiguration);
+ let edits: [(&str, ProjectEdit); 6] = [
+ ("blurred background", blurred_background),
+ ("masks", masks),
+ ("camera3d warp with gaussian focus blur", |project| {
+ camera3d(project, false)
+ }),
+ ("camera3d warp with bokeh focus blur", |project| {
+ camera3d(project, true)
+ }),
+ ("color grade", color_grade),
+ ("device frame and notch", device_frame),
+ ];
+ let mut cases = vec![("every overlay", every_overlay())];
+ let mut everything = every_overlay();
+ for (name, edit) in edits {
+ let mut project = project();
+ edit(&mut project);
+ cases.push((name, project));
+ edit(&mut everything);
+ }
+ cases.push(("everything at once", everything));
+
+ let plain = render_layer_passes(&constants, &project(), false, frames()).await;
+ for (name, project) in &cases {
+ let shared = render_layer_passes(&constants, project, false, frames()).await;
+ let split = render_layer_passes(&constants, project, true, frames()).await;
+ if *name == "device frame and notch"
+ && shared == plain
+ && adapter_cannot_composite(&constants)
+ {
+ eprintln!("software adapter cannot composite {name}, skipping its frame-change check");
+ } else {
+ assert_ne!(shared, plain, "{name} did not change the frame");
+ }
+ assert_eq!(
+ shared, split,
+ "{name} renders differently when its layers share a pass"
+ );
+ }
+
+ let camera_constants = constants_with_camera(directory.path(), Some(XY::new(64, 48))).await;
+ let camera_frames = || DecodedSegmentFrames {
+ camera_frame: Some(DecodedFrame::new(
+ [200, 180, 40, 255].repeat(64 * 48),
+ 64,
+ 48,
+ )),
+ segment_has_camera: true,
+ ..frames()
+ };
+ let mut camera_only_transition = project();
+ camera_only_transition
+ .timeline
+ .as_mut()
+ .unwrap()
+ .scene_segments = serde_json::from_value(serde_json::json!([
+ {"start": 0.9, "end": 3.0, "mode": "cameraOnly"}
+ ]))
+ .unwrap();
+ let without_camera = render_layer_passes(&camera_constants, &project(), false, frames()).await;
+ for (name, project) in [
+ ("camera overlay", project()),
+ ("camera-only scene transition", camera_only_transition),
+ ] {
+ let shared = render_layer_passes(&camera_constants, &project, false, camera_frames()).await;
+ let split = render_layer_passes(&camera_constants, &project, true, camera_frames()).await;
+ if shared == without_camera && adapter_cannot_composite(&camera_constants) {
+ eprintln!("software adapter cannot composite {name}, skipping its camera check");
+ } else {
+ assert_ne!(shared, without_camera, "{name} did not draw the camera");
+ }
+ assert_eq!(
+ shared, split,
+ "{name} renders differently when its layers share a pass"
+ );
+ }
+}