Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
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.rsindex 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.rsindex 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"+ );+ }+}