Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

fix(compositor): keep the camera's corners until Full Camera reaches the frame

EtienneLescotf167122b8d25
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rs
index aa3d9b5a4..c788d92b8 100644
--- a/crates/compositor/src/frame_geometry.rs
+++ b/crates/compositor/src/frame_geometry.rs
@@ -2943,6 +2943,8 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
crate::regions::camera_fullscreen_progress_at(cam_regions, source_t, &clock);
let cam_progress_prev =
crate::regions::camera_fullscreen_progress_at(cam_regions, source_t_prev, &clock);
+ let shape_fade =
+ crate::regions::camera_fullscreen_shape_at(cam_regions, source_t, &clock);
// rétrécissement réactif : la webcam rétrécit pendant un zoom actif, de la MOITIÉ de ce
// que prendrait 1/zoom : ×0,78 au zoom par défaut (1,8), ×0,6 au zoom maximal (5). En
// 1/zoom elle tombait à ×0,56 au zoom par défaut et un visage ne se lisait plus. Ignoré
@@ -3334,12 +3336,11 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
// était une SECONDE, indépendante — fraction différente (0.12 vs 0.06 côté web) et sans
// bornes — donc écran et caméra ne pouvaient pas s'accorder.
let app_webcam_radius_frac = scene.and_then(|s| s.layout.webcam_radius_frac);
- // Full Camera dissout la forme en même temps qu'elle prend le cadre : le rayon fond
- // vers 0 avec `cam_progress`, donc le cercle devient un rect à coins de plus en plus
- // francs puis un plein cadre net — aucun masque ne survit au plein écran (parité
- // `computeCameraFullscreenRect`, qui ramène `maskShape` à "rectangle" et lerpe le
- // rayon vers 0 pour exactement la même raison).
- let shape_fade = (1.0 - cam_progress).clamp(0.0, 1.0);
+ // Full Camera dissout la forme en prenant le cadre : le rayon fond vers 0, donc le cercle
+ // devient un rect à coins de plus en plus francs puis un plein cadre net — aucun masque
+ // ne survit au plein écran. Il fond sur sa propre courbe, en retard sur le rect
+ // (`camera_fullscreen_shape_at`). `computeCameraFullscreenRect` (TS) le lerpe encore
+ // avec le progrès, mais ce rayon-là n'habille qu'une `<video>` cachée.
let w_radius = shape_fade
* w_nominal_min
* match app_webcam_radius_frac {
diff --git a/crates/compositor/src/regions.rs b/crates/compositor/src/regions.rs
index cd5346c6a..097863e29 100644
--- a/crates/compositor/src/regions.rs
+++ b/crates/compositor/src/regions.rs
@@ -951,12 +951,13 @@ pub fn zoom_state_in(
}
}
-/// Port de `computeCameraFullscreenRegionStrength` (TS) : progrès EXACTEMENT contenu dans
-/// [startSec, endSec] (contrairement au zoom, qui anticipe avant `startSec`) — ease-in depuis
-/// 0 pile à `startSec`, plein régime, ease-out jusqu'à 0 pile à `endSec`. Fenêtres bornées à la
-/// moitié de la durée de la région pour que les régions courtes s'animent pleinement sans
-/// déborder. Fenêtres mesurées à l'écran, comme celles du zoom (`ScreenClock`).
-fn camera_fullscreen_region_strength(
+/// Port de `computeCameraFullscreenRegionStrength` (TS), avant son ease : phase LINÉAIRE
+/// EXACTEMENT contenue dans [startSec, endSec] (contrairement au zoom, qui anticipe avant
+/// `startSec`) — montée depuis 0 pile à `startSec`, plein régime, descente jusqu'à 0 pile à
+/// `endSec`. Fenêtres bornées à la moitié de la durée de la région pour que les régions courtes
+/// s'animent pleinement sans déborder. Fenêtres mesurées à l'écran, comme celles du zoom
+/// (`ScreenClock`). Le rect et la bulle y appliquent chacun leur courbe.
+fn camera_fullscreen_region_phase(
region: &SceneCameraFullscreenRegion,
t: f32,
clock: &ScreenClock,
@@ -973,35 +974,32 @@ fn camera_fullscreen_region_strength(
let lead_in_end = start + lead_in;
let lead_out_start = end - lead_out;
if t < lead_in_end {
- let progress = if lead_in > 0.0 {
+ return if lead_in > 0.0 {
(t - start) / lead_in
} else {
1.0
};
- return ease_out_screen_studio(progress);
}
if t <= lead_out_start {
return 1.0;
}
- let progress = if lead_out > 0.0 {
+ if lead_out > 0.0 {
(end - t) / lead_out
} else {
0.0
- };
- ease_out_screen_studio(progress)
+ }
}
-/// Progrès Full Camera (0..1) au temps `t` : 0 = webcam à sa taille normale, 1 = plein cadre.
-/// Régions superposées (ne devrait pas arriver, gardé défensif comme le web) → la plus forte
-/// gagne.
-pub fn camera_fullscreen_progress_at(
+/// Phase Full Camera (0..1) au temps `t`. Régions superposées (ne devrait pas arriver, gardé
+/// défensif comme le web) → la plus forte gagne.
+fn camera_fullscreen_phase_at(
regions: &[SceneCameraFullscreenRegion],
t: f32,
clock: &ScreenClock,
) -> f32 {
let mut strongest = 0.0f32;
for r in regions {
- let s = camera_fullscreen_region_strength(r, t, clock);
+ let s = camera_fullscreen_region_phase(r, t, clock);
if s > strongest {
strongest = s;
}
@@ -1009,6 +1007,29 @@ pub fn camera_fullscreen_progress_at(
strongest
}
+/// Progrès Full Camera (0..1) au temps `t` : 0 = webcam à sa taille normale, 1 = plein cadre.
+pub fn camera_fullscreen_progress_at(
+ regions: &[SceneCameraFullscreenRegion],
+ t: f32,
+ clock: &ScreenClock,
+) -> f32 {
+ ease_out_screen_studio(camera_fullscreen_phase_at(regions, t, clock))
+}
+
+/// Ce qui reste de la bulle PiP (coins arrondis, ombre) au temps `t` : 1 = bulle entière,
+/// 0 = plein cadre net. Pas `1 - progrès` : le rect part en ease-out et a fait 90 % du chemin au
+/// premier tiers de la montée, donc des coins qui le suivaient étaient carrés presque tout du
+/// long, et ne se rearrondissaient qu'à l'arrivée au retour. La bulle tient toute la première
+/// moitié de la montée et se dissout dans la seconde, quand la caméra touche déjà les bords ; au
+/// retour, elle revient dans la première moitié, avant que la caméra ne quitte le cadre.
+pub fn camera_fullscreen_shape_at(
+ regions: &[SceneCameraFullscreenRegion],
+ t: f32,
+ clock: &ScreenClock,
+) -> f32 {
+ 1.0 - smoothstep(0.5, 1.0, camera_fullscreen_phase_at(regions, t, clock))
+}
+
// ============ Rotation 3D (tilt perspective, présets iso/left/right) ================
// Port de `computeRotation3DContainScale` (TS, `types.ts`) — même formule, même ordre de
// composition ("CSS rotateX rotateY rotateZ s'applique droite-à-gauche : Z d'abord, puis Y,
@@ -1970,6 +1991,25 @@ mod zoom_focus_tests {
}
}
+ /// Les coins suivent la phase, pas le rect. Avec `1 - progrès`, ils étaient carrés presque
+ /// tout du long de la montée et ne revenaient qu'à la toute fin du retour.
+ #[test]
+ fn full_camera_corners_dissolve_late_and_come_back_early() {
+ let r = [SceneCameraFullscreenRegion { clip_index: None, start_sec: 10.0, end_sec: 20.0 }];
+ let clock = ScreenClock::default();
+ let at = |t: f32| {
+ (camera_fullscreen_progress_at(&r, t, &clock), camera_fullscreen_shape_at(&r, t, &clock))
+ };
+ // Premier tiers de la montée : la caméra a fait l'essentiel du chemin, coins intacts.
+ let (progress, shape) = at(10.0 + TRANSITION_WINDOW_S / 3.0);
+ assert!(progress > 0.85 && shape == 1.0, "montée : {progress} / {shape}");
+ // Mi-retour : les coins sont revenus, la caméra a à peine quitté le cadre.
+ let (progress, shape) = at(20.0 - FULLSCREEN_LEAD_OUT_WINDOW_S / 2.0);
+ assert!(progress > 0.95 && shape > 0.999, "retour : {progress} / {shape}");
+ assert_eq!(at(15.0), (1.0, 0.0), "plein cadre : plus de coins");
+ assert_eq!(at(5.0), (0.0, 1.0), "hors région : la bulle entière");
+ }
+
/// Le cas réel : la speed region commence au milieu de l'ease-in. Le zoom doit durer autant de
/// frames de sortie qu'à 1× (l'export avance de `vitesse / fps` de source par frame), sans saut.
#[test]
diff --git a/technical-documentation/architecture/native-compositor.md b/technical-documentation/architecture/native-compositor.md
index b8ac7ffac..5ba542659 100644
--- a/technical-documentation/architecture/native-compositor.md
+++ b/technical-documentation/architecture/native-compositor.md
@@ -132,8 +132,10 @@ what `shaders.hlsl` actually implements:
mirror, mask shape (rectangle / circle / square / rounded), and reactive
scale applied
([`compositor.rs:2127`](../../crates/compositor/src/compositor_windows.rs), `mode = 0`).
- Full Camera lerps the destination to `[0, 0, 1, 1]` and dissolves the mask
- shape — same rule as `computeCameraFullscreenRect` on the TS side.
+ Full Camera lerps the destination to `[0, 0, 1, 1]`, same rule as
+ `computeCameraFullscreenRect` on the TS side, and dissolves the mask shape
+ on its own, later curve (`camera_fullscreen_shape_at`): the corners hold
+ while the camera grows and square off once it reaches the frame edges.
7. **Annotations.** Highest layer. One full-frame `CopySubresourceRegion` of
the composed scene is taken at the top of `draw_annotations` so that
multiple blur annotations on the same frame read from a consistent snapshot