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): shrink the webcam toward its anchor and give auto-follow a dead zone

EtienneLescot5868677fdb45
diff --git a/crates/compositor/src/cursor.rs b/crates/compositor/src/cursor.rs
index 5ce803f38..2b44e5d75 100644
--- a/crates/compositor/src/cursor.rs
+++ b/crates/compositor/src/cursor.rs
@@ -12,6 +12,11 @@ const AUTO_FOLLOW_MAX_FACTOR: f32 = 0.25;
const AUTO_FOLLOW_RAMP_DISTANCE: f32 = 0.15;
const AUTO_FOLLOW_REFERENCE_MS: f32 = 1000.0 / 40.0;
+/// Part de la vue zoomée, par axe, où le pointeur bouge sans que la vue le suive : sa moitié
+/// centrale (`follow_in_view`). Au-delà, la vue le rattrape juste assez pour le ramener au bord de
+/// cette zone. Sans elle, la vue suivait chaque petit geste et le cadrage paraissait nerveux.
+const FOLLOW_DEAD_ZONE: f32 = 0.5;
+
// Convergence du curseur dessiné sur le point cliqué (`pinned_at`). La tenue couvre le contact du
// curseur modélisé (27 à 74 ms après le clic), plus une image à 24 i/s.
const PIN_APPROACH_S: f32 = 0.25;
@@ -92,18 +97,24 @@ fn smooth_follow_samples(samples: &[(f32, f32, f32)]) -> Vec<(f32, f32, f32)> {
prev = Some((t, px, py));
continue;
}
- let (dx, dy) = (x - px, y - py);
- let distance = (dx * dx + dy * dy).sqrt();
- let ramp = (distance / AUTO_FOLLOW_RAMP_DISTANCE).min(1.0);
- let base = AUTO_FOLLOW_MIN_FACTOR + (AUTO_FOLLOW_MAX_FACTOR - AUTO_FOLLOW_MIN_FACTOR) * ramp;
- let factor = 1.0 - (1.0 - base).powf(dt_ms / AUTO_FOLLOW_REFERENCE_MS);
- let (nx, ny) = (px + dx * factor, py + dy * factor);
+ let (nx, ny) = follow_step((px, py), (x, y), dt_ms);
smoothed.push((t, nx, ny));
prev = Some((t, nx, ny));
}
smoothed
}
+/// Un pas du lissage de suivi : `from` avance vers `to` d'un facteur qui croît avec la distance
+/// (loin = rattrape vite, près = décélère), corrigé en temps sur `dt_ms`.
+fn follow_step(from: (f32, f32), to: (f32, f32), dt_ms: f32) -> (f32, f32) {
+ let (dx, dy) = (to.0 - from.0, to.1 - from.1);
+ let distance = (dx * dx + dy * dy).sqrt();
+ let ramp = (distance / AUTO_FOLLOW_RAMP_DISTANCE).min(1.0);
+ let base = AUTO_FOLLOW_MIN_FACTOR + (AUTO_FOLLOW_MAX_FACTOR - AUTO_FOLLOW_MIN_FACTOR) * ramp;
+ let factor = 1.0 - (1.0 - base).powf(dt_ms / AUTO_FOLLOW_REFERENCE_MS);
+ (from.0 + dx * factor, from.1 + dy * factor)
+}
+
impl CursorTrack {
/// Seul point de construction : garantit que `follow_samples` est toujours dérivé des
/// échantillons courants. Une piste re-lissée (`smoothed`) recalcule donc aussi son suivi,
@@ -175,6 +186,37 @@ impl CursorTrack {
sample_at(&self.follow_samples, t)
}
+ /// Le centre de la vue d'un zoom auto d'échelle `scale` à `t`, parti de `follow_at(t0)` en
+ /// `t0` : `follow_at` avec une zone morte. La vue ne bouge pas tant que le pointeur reste dans
+ /// la part `FOLLOW_DEAD_ZONE` de sa largeur autour de son centre ; il en sort, elle le
+ /// rattrape avec le même lissage, juste assez pour le ramener au bord de la zone. Bornée à ce
+ /// qu'une vue de `1/scale` peut atteindre, pour que la zone se mesure contre la vue affichée.
+ ///
+ /// Rejouée depuis `t0` à chaque appel, sur les échantillons BRUTS : une pure fonction de
+ /// `(t0, t)`, donc la même en preview et à l'export, en lecture comme après un seek. Le coût
+ /// suit la durée de la région, pas celle de la piste.
+ pub fn follow_in_view(&self, t0: f32, t: f32, scale: f32) -> Option<(f32, f32)> {
+ let half = 0.5 / scale.max(1.0);
+ let dead = half * FOLLOW_DEAD_ZONE;
+ let reach = |v: f32| v.clamp(half, 1.0 - half);
+ // La cible : le point qui ramène le pointeur au bord de la zone, la vue elle-même dedans.
+ let pull = |cursor: f32, view: f32| cursor - (cursor - view).clamp(-dead, dead);
+ let (x0, y0) = self.follow_at(t0)?;
+ let (mut at, mut view) = (t0, (reach(x0), reach(y0)));
+ let first = self.samples.partition_point(|s| s.0 <= t0);
+ for &(ts, x, y) in &self.samples[first..] {
+ let (nx, ny) = follow_step(view, (pull(x, view.0), pull(y, view.1)), (ts - at) * 1000.0);
+ let next = (reach(nx), reach(ny));
+ if ts >= t {
+ // Entre deux échantillons, linéaire, comme `follow_at`.
+ let f = if ts > at { ((t - at) / (ts - at)).clamp(0.0, 1.0) } else { 1.0 };
+ return Some((view.0 + (next.0 - view.0) * f, view.1 + (next.1 - view.1) * f));
+ }
+ (at, view) = (ts, next);
+ }
+ Some(view)
+ }
+
/// Position (cx, cy) au temps `t` (interpolation linéaire), ou None si hors piste. Brute, sauf
/// sur une piste `smoothed()`.
pub fn at(&self, t: f32) -> Option<(f32, f32)> {
@@ -412,6 +454,33 @@ fn cursor_spring_config(smoothing_factor: f32) -> (f32, f32, f32) {
mod tests {
use super::*;
+ /// Zone morte du suivi auto : un pointeur qui tremble au centre de la vue ne la bouge pas ;
+ /// un pointeur qui part loin est rattrapé, jusqu'au bord de la zone et pas au-delà.
+ #[test]
+ fn the_auto_follow_holds_still_inside_its_dead_zone() {
+ // ×2 : vue de 0,5, zone morte de ±0,125 autour de son centre.
+ let track = |f: fn(f32) -> f32| {
+ CursorTrack::new((0..=300).map(|i| { let t = i as f32 / 30.0; (t, f(t), 0.5) }).collect(), vec![], vec![])
+ };
+ let jitter = track(|t| 0.5 + 0.08 * (t * 7.0).sin());
+ for i in 0..=90 {
+ let (x, y) = jitter.follow_in_view(0.0, i as f32 / 10.0, 2.0).unwrap();
+ assert!((x - 0.5).abs() < 1e-6 && (y - 0.5).abs() < 1e-6, "t {} : {x}", i as f32 / 10.0);
+ }
+ // Sans zone morte, le suivi lissé, lui, tremble.
+ let swing = (0..=90).map(|i| jitter.follow_at(i as f32 / 10.0).unwrap().0).fold(0.0f32, |m, x| m.max((x - 0.5).abs()));
+ assert!(swing > 0.02, "{swing}");
+
+ // Un saut à 0,8 à 2 s : la vue rattrape jusqu'à laisser le pointeur au bord de la zone.
+ let jump = track(|t| if t < 2.0 { 0.5 } else { 0.8 });
+ let settled = jump.follow_in_view(0.0, 9.0, 2.0).unwrap().0;
+ assert!((settled - (0.8 - 0.125)).abs() < 1e-3, "{settled}");
+ let early = jump.follow_in_view(0.0, 2.1, 2.0).unwrap().0;
+ assert!(early > 0.5 && early < settled, "rattrapage progressif : {early}");
+ // Une pure fonction de (t0, t) : l'ordre des appels ne change rien.
+ assert_eq!(jump.follow_in_view(0.0, 2.1, 2.0).unwrap().0, early);
+ }
+
/// L'état du curseur est une fonction en escalier : il tient jusqu'à la transition
/// suivante, il n'est pas interpolé, et avant la première il n'y en a pas.
#[test]
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rs
index b02685abe..bfab0d4d2 100644
--- a/crates/compositor/src/frame_geometry.rs
+++ b/crates/compositor/src/frame_geometry.rs
@@ -2714,9 +2714,8 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
let mut zoom_orbit = [0.5f32; 2];
let (mut zoom_aim_prev, mut zoom_orbit_prev) = ([0.5f32; 2], [0.5f32; 2]);
// Curseur masqué → pas de piste pour ce qui anime le plan (parallaxe, impact, caméra
- // `follow-cursor`) : l'export ne charge la piste que si le curseur est affiché
- // (`timeline_walk`), la preview toujours. Sans cette porte, la preview pencherait un
- // plan que l'export laisse immobile.
+ // `follow-cursor`) : un plan ne bouge que sous un pointeur qu'on voit. Preview et export
+ // chargent la piste dans tous les cas (le focus auto la suit), cette porte fait le reste.
let parallax_track = cursor_for_zoom.filter(|_| scene.is_some_and(|s| s.cursor.show));
let active_crop = scene.and_then(|scene| {
scene.crop_by_clip.get(scene.active_clip_index).copied().flatten()
@@ -2812,21 +2811,25 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
let (brx, bry) = (dst[0] + dst[2], dst[1] + dst[3]);
[brx - nw, bry - nh, nw, nh]
};
- // Variantes ancrées au CENTRE (au lieu du coin bas-droite) de `dst`, pour le cas où
- // `dst` vient de `app_webcam_rect` : ce rect est déjà la position que l'utilisateur a
- // choisie/déplacée (résolue côté app via `computeCompositeLayout`, même convention
- // centre-fraction que `cx`/`cy` dans `compositeLayout.ts`) — l'ancrer au coin bas-droite
- // comme le fait `fit_cam_aspect` (pensé pour le placement par DÉFAUT, ancré à ce coin
- // avec une marge fixe) réancre silencieusement la webcam glissée n'importe où d'autre à
- // ce coin, ignorant la position réelle choisie par l'utilisateur — le bug rapporté
- // (webcam glissée au coin bas-gauche, DOM/JSON envoyé au natif confirmant une position
- // flush, mais rendu natif visiblement décalé). Le centre est le point fixe qui a un sens
- // pour un rect DÉJÀ positionné par l'app ; le coin bas-droite n'a de sens que pour le
- // placement par défaut, qui grandit depuis ce coin faute de position explicite.
- let scale_center = |dst: [f32; 4], s: f32| -> [f32; 4] {
- let (cx, cy) = (dst[0] + dst[2] * 0.5, dst[1] + dst[3] * 0.5);
+ // Variante ancrée à l'ANCRE de la caméra (au lieu du coin bas-droite) de `dst`, pour le cas
+ // où `dst` vient de `app_webcam_rect` : ce rect est déjà la position que l'utilisateur a
+ // choisie (résolue côté app via `computeCompositeLayout`) — l'ancrer au coin bas-droite
+ // comme le fait `fit_cam_aspect` (pensé pour le placement par DÉFAUT) réancrerait la
+ // webcam posée n'importe où d'autre à ce coin (bug rapporté : webcam au coin bas-gauche,
+ // rendu natif décalé).
+ //
+ // L'app pose la caméra à marge constante de son ancre (un coin ou un milieu de bord) :
+ // `x = marge + fx·(W − 2·marge − w)`, donc le point de la boîte à la fraction `fx` vaut
+ // `marge + fx·(W − 2·marge)` quelle que soit sa largeur. Rétrécir autour de ce point-là,
+ // c'est exactement la mise en page de l'app à la taille réduite : une caméra de coin garde
+ // sa marge aux deux bords, une caméra de milieu de bord reste centrée sur lui. Rétrécir
+ // vers son propre centre l'arrachait de son coin pendant chaque zoom. Sans ancre (vieux
+ // payload), le centre.
+ let anchor = scene.map(|s| s.layout.webcam_anchor_fractions()).unwrap_or([0.5, 0.5]);
+ let scale_anchored = |dst: [f32; 4], s: f32| -> [f32; 4] {
+ let (ax, ay) = (dst[0] + dst[2] * anchor[0], dst[1] + dst[3] * anchor[1]);
let (nw, nh) = (dst[2] * s, dst[3] * s);
- [cx - nw * 0.5, cy - nh * 0.5, nw, nh]
+ [ax - nw * anchor[0], ay - nh * anchor[1], nw, nh]
};
// Le ratio de sortie réel (peut différer du canvas interne 16:9 fixe) et le facteur
// d'étirement non uniforme que `blit_resized` appliquera en fin de pipeline — nécessaires
@@ -3013,17 +3016,17 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
// (`OUT_W`×`OUT_H`), une référence différente du vrai output dès que la sortie n'est pas
// 16:9 (rapport utilisateur : webcam glissée au coin bas-gauche en 9:16, JSON envoyé au
// natif confirmant une position flush, mais rendu native visiblement décalé ET trop
- // petit). On garde seulement `scale_center` (zoom réactif, préserve position+aspect) puis
- // on pré-compense par `inverse_undistort` pour annuler le `undistort()` générique
+ // petit). On garde seulement `scale_anchored` (zoom réactif, préserve l'ancre et l'aspect)
+ // puis on pré-compense par `inverse_undistort` pour annuler le `undistort()` générique
// appliqué plus bas à tous les calques (écran compris) — sans quoi ce rect déjà correct
// se ferait déformer une seconde fois par cet undistort partagé.
let mut w_dst = if app_webcam_rect.is_some() {
- scale_center(p.webcam.dst, webcam_size_scale)
+ scale_anchored(p.webcam.dst, webcam_size_scale)
} else {
fit_cam_aspect(scale_corner_br(p.webcam.dst, webcam_size_scale))
};
let mut w_dst_prev = if app_webcam_rect.is_some() {
- scale_center(pp.webcam.dst, webcam_size_scale_prev)
+ scale_anchored(pp.webcam.dst, webcam_size_scale_prev)
} else {
fit_cam_aspect(scale_corner_br(pp.webcam.dst, webcam_size_scale_prev))
};
@@ -3291,8 +3294,8 @@ pub fn cursor_plane_point(cut: [f32; 4], uv_max: [f32; 2], p: (f32, f32)) -> Opt
/// multiplier encore par le poids des régions (`ZoomState::click_impact`) ; la porte du préset
/// vient ensuite, dans `dynamic_tilt`.
///
-/// - curseur visible (`cursor_alpha`) : `cursor.show` explicite, parce que l'export ne charge la
-/// piste que si le curseur est affiché alors que la preview la charge toujours ;
+/// - curseur visible (`cursor_alpha`) : `cursor.show` explicite, la piste étant chargée même
+/// curseur masqué (le focus auto la suit) ;
/// - clics dans la fenêtre source du clip actif seulement (cf. `click_impact`) ;
/// - vitesse : poids `clamp(2 − vitesse, 0, 1)`. À 100× une frame couvre 3,3 s de source, la
/// courbe serait échantillonnée une fois, au hasard : une secousse d'une frame ;
@@ -5888,6 +5891,35 @@ mod tests {
assert_eq!((still.trail_a, still.trail_b), (still.fx, still.src_prev));
}
+ /// Le zoom réactif rétrécit la caméra vers son ANCRE : une caméra de coin garde sa marge aux
+ /// deux bords, une caméra de milieu de bord reste centrée sur lui. Sans ancre, le centre.
+ #[test]
+ fn the_reactive_zoom_shrinks_the_camera_toward_its_anchor() {
+ let cfg = crate::config::all().pop().expect("au moins une config");
+ // Caméra de 0,2 de côté posée par l'app, marge 0,03 ; zoom ×2 à 1,5 s → échelle 0,5.
+ let camera_at = |anchor: Option<&str>, x: f32, y: f32| {
+ let anchor = anchor.map(|a| format!(r#","webcamAnchor":"{a}""#)).unwrap_or_default();
+ let layout = format!(
+ r#""webcamReactiveZoom":true{anchor},"webcamRect":{{"x":{x},"y":{y},"width":0.2,"height":0.2}}}}"#
+ );
+ let json = zoomed_golden_scene_json().replace(r#""webcamReactiveZoom":false}"#, &layout);
+ let scene = Scene::from_json(&json).expect("scène");
+ plan_frame(&golden_input(&scene, &cfg)).w_dst
+ };
+ for (anchor, x, y, want) in [
+ (Some("bottom-right"), 0.77, 0.77, [0.87, 0.87]),
+ (Some("top-left"), 0.03, 0.03, [0.03, 0.03]),
+ (Some("bottom"), 0.4, 0.77, [0.45, 0.87]),
+ (Some("left"), 0.03, 0.4, [0.03, 0.45]),
+ (None, 0.77, 0.77, [0.82, 0.82]),
+ ] {
+ let w = camera_at(anchor, x, y);
+ let got = [w[0], w[1], w[2], w[3]];
+ let want = [want[0], want[1], 0.1, 0.1];
+ assert!(got.iter().zip(want).all(|(g, w)| (g - w).abs() < 1e-5), "{anchor:?} : {got:?} au lieu de {want:?}");
+ }
+ }
+
/// La vitesse se mesure dans la coupe VISIBLE, zoom compris : sous un x2, le même geste
/// traverse deux fois plus d'écran et penche donc plus le plan (hors saturation).
#[test]
diff --git a/crates/compositor/src/regions.rs b/crates/compositor/src/regions.rs
index 27f0ba5e7..76b9a7d97 100644
--- a/crates/compositor/src/regions.rs
+++ b/crates/compositor/src/regions.rs
@@ -660,10 +660,12 @@ fn resolve_focus(region: &SceneZoomRegion, t: f32, cursor: Option<&CursorTrack>)
}
if region.focus_mode.as_deref() == Some("auto") {
if let Some(track) = cursor {
- // `follow_at`, pas `at` : la caméra suit la piste LISSÉE. Suivre la télémétrie brute
- // donne un pan nerveux — l'étage de lissage de `cursorFollowUtils.ts` manquait au
- // portage.
- if let Some((cx, cy)) = track.follow_at(t) {
+ // La piste LISSÉE, avec une zone morte au centre de la vue zoomée (`follow_in_view`) :
+ // la vue ne bouge que quand le pointeur en sort. Suivre la télémétrie brute, ou chaque
+ // petit geste, donne un pan nerveux. Le filtre part du début de l'ease-in de la région,
+ // un instant fixe : preview et export rejouent la même chose.
+ let t0 = region.start_sec as f32 - zoom_transition_s(region.scale);
+ if let Some((cx, cy)) = track.follow_in_view(t0, t, region.scale) {
return [cx, cy];
}
}
@@ -1454,11 +1456,12 @@ mod zoom_focus_tests {
let track = CursorTrack::new(vec![(3.0, 0.8, 0.2), (4.0, 0.9, 0.1)], Vec::new(), Vec::new());
let mut r = region(1.5, 0.1);
r.focus_mode = Some("auto".into());
- let last = track.follow_at(4.0).unwrap();
+ let t0 = r.start_sec as f32 - zoom_transition_s(r.scale);
+ let last = track.follow_in_view(t0, 4.0, r.scale).unwrap();
for t in [4.5f32, 6.0, 7.9] {
assert_eq!(resolve_focus(&r, t, Some(&track)), [last.0, last.1], "t = {t}");
}
- let first = track.follow_at(3.0).unwrap();
+ let first = track.follow_in_view(t0, 2.1, r.scale).unwrap();
assert_eq!(resolve_focus(&r, 2.1, Some(&track)), [first.0, first.1]);
}
diff --git a/crates/compositor/src/scene.rs b/crates/compositor/src/scene.rs
index 4e2f46c0e..b6004c7c9 100644
--- a/crates/compositor/src/scene.rs
+++ b/crates/compositor/src/scene.rs
@@ -45,6 +45,11 @@ pub struct SceneLayout {
pub webcam_position: Option<WebcamPosition>,
/// la webcam rétrécit pendant un zoom actif.
pub webcam_reactive_zoom: bool,
+ /// Picture-in-picture : le coin ou le milieu de bord où la caméra est ancrée, à marge
+ /// constante du bord (`WEBCAM_ANCHORS`, TS : "top-left", "top", …, "bottom-right"). Le
+ /// rétrécissement du zoom réactif se fait vers lui (`anchor_fractions`). Absent : le centre.
+ #[serde(default)]
+ pub webcam_anchor: Option<String>,
/// User-authored source crop for the camera. Absent keeps the full frame.
#[serde(default)]
pub webcam_crop: Option<SceneCrop>,
@@ -111,6 +116,19 @@ pub struct SceneLayout {
pub webcam_radius_frac: Option<f32>,
}
+impl SceneLayout {
+ /// L'ancre de la caméra en fractions de sa boîte, par axe : 0, 0,5 ou 1, la part de la place
+ /// libre qu'elle laisse d'un côté (`webcamAnchorFractions`, TS). Le centre sans ancre.
+ pub fn webcam_anchor_fractions(&self) -> [f32; 2] {
+ let Some(anchor) = self.webcam_anchor.as_deref() else { return [0.5, 0.5] };
+ let side = |low: bool, high: bool| if low { 0.0 } else if high { 1.0 } else { 0.5 };
+ [
+ side(anchor.ends_with("left"), anchor.ends_with("right")),
+ side(anchor.starts_with("top"), anchor.starts_with("bottom")),
+ ]
+ }
+}
+
/// La moitié du layout qui dépend de la FORME de la source, résolue pour un clip.
/// Voir `SceneLayout::layout_by_clip`.
///
diff --git a/crates/compositor/src/timeline_walk.rs b/crates/compositor/src/timeline_walk.rs
index 67218ccf8..f139e6a2c 100644
--- a/crates/compositor/src/timeline_walk.rs
+++ b/crates/compositor/src/timeline_walk.rs
@@ -158,7 +158,11 @@ pub(crate) unsafe fn walk_composited_timeline(
on_frame: &mut dyn FnMut(u64) -> Result<()>,
on_clip_end: &mut dyn FnMut(usize, f64, u64, &[SpeedSegment]) -> Result<()>,
) -> Result<u64> {
- let cursor_enabled = scene.as_ref().map(|s| s.cursor.show).unwrap_or(false);
+ // La piste se charge même curseur MASQUÉ : le focus auto des zooms la suit, comme en preview
+ // (qui la charge toujours). Sans elle, un zoom auto suivait en preview et restait figé à
+ // l'export. Ce qui ne doit rien voir d'un curseur masqué a sa propre porte sur `cursor.show` :
+ // le dessin (`cursor_alpha`), la parallaxe, l'impact du clic et la caméra `follow-cursor`.
+ let cursor_enabled = scene.is_some();
let cursor_smoothing = scene.as_ref().map(|s| s.cursor.smoothing).unwrap_or(0.0);
let mut cursor_tracks: HashMap<String, CursorTrack> = HashMap::new();
let mut cursor_active_path: Option<String> = None;
diff --git a/src/components/video-editor/types.ts b/src/components/video-editor/types.ts
index e12534f5c..c135c8536 100644
--- a/src/components/video-editor/types.ts
+++ b/src/components/video-editor/types.ts
@@ -84,7 +84,7 @@ export type FixedRotation3DPreset = (typeof FIXED_ROTATION_3D_PRESETS)[number];
* A moving 3D camera. `follow-cursor` keeps the screen still and moves a real camera around it:
* the camera orbits to the side the cursor is on and rises or dips with it, always level. The
* native compositor renders it (`crates/compositor/src/camera.rs`). It needs the cursor track,
- * which the export only loads while the cursor is shown.
+ * which only drives it while the cursor is shown.
*/
export const MOVING_ROTATION_3D_PRESETS = ["follow-cursor"] as const;
export type MovingRotation3DPreset = (typeof MOVING_ROTATION_3D_PRESETS)[number];
diff --git a/src/native/sceneDescription.test.ts b/src/native/sceneDescription.test.ts
index 8500e89e5..4610b011f 100644
--- a/src/native/sceneDescription.test.ts
+++ b/src/native/sceneDescription.test.ts
@@ -1207,6 +1207,15 @@ describe("buildSceneDescription.settings mapping", () => {
expect(buildSceneDescription(high).layout.webcamSize).toBeCloseTo(0.35, 5);
});
+ it("carries the camera's anchor, the point its zoom-time shrink keeps fixed", () => {
+ expect(buildSceneDescription(makeDoc({})).layout.webcamAnchor).toBe("bottom-right");
+ const top = makeDoc({ legacyEditor: { webcamAnchor: "top" } });
+ expect(buildSceneDescription(top).layout.webcamAnchor).toBe("top");
+ // An older project stored a free position: it reads as the anchor nearest to it.
+ const legacy = makeDoc({ legacyEditor: { webcamPosition: { cx: 0.1, cy: 0.9 } } });
+ expect(buildSceneDescription(legacy).layout.webcamAnchor).toBe("bottom-left");
+ });
+
it("keeps the flat cursor for an older project and carries the 3D cursor switch", () => {
expect(buildSceneDescription(makeDoc({ legacyEditor: {} })).cursor.model3d).toBe(false);
const on = makeDoc({ legacyEditor: { cursorModel3d: true } });
diff --git a/src/native/sceneDescription.ts b/src/native/sceneDescription.ts
index 62722544a..9094a616f 100644
--- a/src/native/sceneDescription.ts
+++ b/src/native/sceneDescription.ts
@@ -60,7 +60,7 @@ import {
webcamSizeToFraction,
} from "@/lib/compositeLayout";
import { parseCssGradient, resolveLinearGradientAngle } from "@/lib/exporter/gradientParser";
-import type { FrameTheme, RecordingFrame } from "@/lib/projectDefaults";
+import type { FrameTheme, RecordingFrame, WebcamAnchor } from "@/lib/projectDefaults";
import { resolveTextFontFamily } from "@/lib/textFonts";
import type { CompositorClipInput } from "./contracts";
import { ROUNDNESS_REFERENCE_PX } from "./paramUnits";
@@ -278,6 +278,12 @@ export interface SceneLayout {
webcamPosition: { cx: number; cy: number } | null;
/** Webcam shrinks while a zoom region is active. */
webcamReactiveZoom: boolean;
+ /**
+ * Picture-in-picture: the corner or edge middle the camera is anchored to, at a constant
+ * margin from the border (`computeCompositeLayout`). The zoom-time shrink keeps that anchor
+ * fixed, so a corner camera keeps its margin to both edges.
+ */
+ webcamAnchor: WebcamAnchor;
/** User-authored webcam framing, as fractions of the camera source. */
webcamCrop: { x: number; y: number; width: number; height: number };
/**
@@ -1158,6 +1164,7 @@ export function buildSceneDescription(
settings.webcamLayoutPreset,
settings.webcamReactiveZoom,
),
+ webcamAnchor: settings.webcamAnchor,
webcamCrop: settings.webcamCropRegion,
webcamRect,
screenRect,