Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(rendering): use current camera dimensions for layout

Aditya Garud98b5cfc9046b
diff --git a/crates/rendering/src/lib.rs b/crates/rendering/src/lib.rs
index 6abde058f..1b9e172c1 100644
--- a/crates/rendering/src/lib.rs
+++ b/crates/rendering/src/lib.rs
@@ -4105,6 +4105,12 @@ impl ProjectUniforms {
cursor_event_order: CursorEventOrder,
) -> Self {
let options = &constants.options;
+ let camera_size = options.camera_size.map(|size| {
+ segment_frames
+ .camera_frame
+ .as_ref()
+ .map_or(size, |frame| XY::new(frame.width(), frame.height()))
+ });
let output_size = Self::get_output_size(options, project, resolution_base);
let fps_f32 = fps.max(1) as f32;
let timeline_time = f64::from(frame_number) / f64::from(fps.max(1));
@@ -4246,8 +4252,7 @@ impl ProjectUniforms {
// camera and cursor layers. Only engages when a camera actually exists;
// otherwise the layers render normally (graceful full-screen fallback).
let split_layout: Option<SplitLayoutComputed> = if scene.is_split() {
- options
- .camera_size
+ camera_size
.filter(|_| !project.camera.hide)
.map(|camera_size| {
let out_w = output_size.0 as f32;
@@ -4795,8 +4800,7 @@ impl ProjectUniforms {
display_outer_bounds
};
- let camera = options
- .camera_size
+ let camera = camera_size
.filter(|_| !project.camera.hide && scene.should_render_camera())
.map(|camera_size| {
let output_size = [output_size.0 as f32, output_size.1 as f32];
@@ -5005,8 +5009,7 @@ impl ProjectUniforms {
}
});
- let camera_only = options
- .camera_size
+ let camera_only = camera_size
.filter(|_| !project.camera.hide && scene.is_transitioning_camera_only())
.map(|camera_size| {
let output_size = [output_size.0 as f32, output_size.1 as f32];
diff --git a/crates/rendering/tests/camera_frame_geometry.rs b/crates/rendering/tests/camera_frame_geometry.rs
new file mode 100644
index 000000000..16b626f84
--- /dev/null
+++ b/crates/rendering/tests/camera_frame_geometry.rs
@@ -0,0 +1,132 @@
+use cap_project::{CameraShape, CursorEvents, ProjectConfiguration, RecordingMeta, XY};
+use cap_rendering::{
+ DecodedFrame, DecodedSegmentFrames, FrameRenderer, ProjectUniforms, RenderOptions,
+ RenderVideoConstants, RendererLayers, ZoomTransformTimeline,
+};
+
+#[tokio::test]
+async fn camera_geometry_matches_a_project_with_the_current_clips_dimensions() {
+ let metadata: RecordingMeta = serde_json::from_value(serde_json::json!({
+ "pretty_name": "camera-frame-geometry",
+ "display": { "path": "display.mp4", "fps": 30 },
+ "camera": { "path": "camera.mp4", "fps": 30 },
+ "audio": null, "cursor": null
+ }))
+ .unwrap();
+ let studio = metadata.studio_meta().unwrap().clone();
+ let screen_size = XY::new(160, 90);
+ let first_camera_size = XY::new(80, 60);
+ let mut constants = RenderVideoConstants::new_with_options(
+ RenderOptions {
+ screen_size,
+ camera_size: Some(first_camera_size),
+ preserve_screen_alpha: false,
+ },
+ metadata,
+ studio,
+ )
+ .await
+ .unwrap();
+ let cursor = CursorEvents::default();
+ let mut project = ProjectConfiguration::default();
+ project.cursor.hide = true;
+ project.camera.shadow = 0.0;
+ project.camera.size = 25.0;
+ let mut layers = RendererLayers::new(&constants.device, &constants.queue);
+
+ for (width, height) in [(81, 45), (45, 81), (80, 60)] {
+ let camera_size = XY::new(width, height);
+ let camera = image::RgbaImage::from_fn(width, height, |x, y| {
+ image::Rgba([(x * 3) as u8, (y * 3) as u8, 100, 255])
+ });
+ let frames = DecodedSegmentFrames {
+ screen_size,
+ screen_frame: Some(DecodedFrame::new(
+ [20, 30, 40, 255].repeat(screen_size.x as usize * screen_size.y as usize),
+ screen_size.x,
+ screen_size.y,
+ )),
+ camera_frame: Some(DecodedFrame::new(camera.into_raw(), width, height)),
+ segment_time: 3.0 + width as f32 / 1000.0,
+ recording_time: 3.0 + width as f32 / 1000.0,
+ segment_has_camera: true,
+ };
+ for mode in ["default", "cameraOnly", "splitScreen", "floating"] {
+ project.timeline = Some(
+ serde_json::from_value(serde_json::json!({
+ "segments": [],
+ "zoomSegments": [{
+ "start": 0.0, "end": 6.0, "amount": 2.0,
+ "mode": {"manual": {"x": 0.5, "y": 0.5}}
+ }],
+ "sceneSegments": [{
+ "start": 2.0, "end": 5.0, "mode": mode,
+ "transitionIn": 0.3, "transitionOut": 0.3
+ }]
+ }))
+ .unwrap(),
+ );
+ for shape in [CameraShape::Source, CameraShape::Square] {
+ project.camera.shape = shape;
+ for number in [56, 90, 145] {
+ let zoom =
+ ZoomTransformTimeline::from_project(&project, &cursor, 6.0, screen_size);
+ constants.options.camera_size = Some(first_camera_size);
+ let actual = ProjectUniforms::new(
+ &constants,
+ &project,
+ number,
+ 30,
+ screen_size,
+ &cursor,
+ &frames,
+ 6.0,
+ &zoom,
+ );
+ constants.options.camera_size = Some(camera_size);
+ let expected = ProjectUniforms::new(
+ &constants,
+ &project,
+ number,
+ 30,
+ screen_size,
+ &cursor,
+ &frames,
+ 6.0,
+ &zoom,
+ );
+ let mut renderer = FrameRenderer::new(&constants);
+ let actual = renderer
+ .render_immediate(frames.clone(), actual, &cursor, true, &mut layers)
+ .await
+ .unwrap();
+ let mut fresh = RendererLayers::new(&constants.device, &constants.queue);
+ let expected = renderer
+ .render_immediate(frames.clone(), expected, &cursor, true, &mut fresh)
+ .await
+ .unwrap();
+ let error = actual
+ .data
+ .chunks_exact(actual.padded_bytes_per_row as usize)
+ .zip(
+ expected
+ .data
+ .chunks_exact(expected.padded_bytes_per_row as usize),
+ )
+ .flat_map(|(a, b)| {
+ a[..actual.width as usize * 4]
+ .iter()
+ .zip(&b[..expected.width as usize * 4])
+ })
+ .map(|(a, b)| a.abs_diff(*b))
+ .max()
+ .unwrap();
+ assert_eq!(
+ error, 0,
+ "camera {width}x{height}, mode {mode}, shape {shape:?}, frame {number}"
+ );
+ }
+ }
+ }
+ }
+}