Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.tsindex 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.tsindex 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.tsindex 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,