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 blur masks and motion blur right on a tilted filled card

EtienneLescot124f622474f4
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rs
index 45909be89..f7affa9dc 100644
--- a/crates/compositor/src/frame_geometry.rs
+++ b/crates/compositor/src/frame_geometry.rs
@@ -1932,6 +1932,13 @@ pub struct FrameGeometry {
pub padding_scale: f32,
/// Coupe source de l'écran en UV texture (crop utilisateur + zoom).
pub cut: [f32; 4],
+ /// La coupe que montrerait le même écran à plat : le repère du métrage (annotations, effets,
+ /// gimbal de l'éditeur). Égale à `cut`, sauf sous le remplissage incliné, où `cut` n'est plus
+ /// que la fenêtre zoomée qu'en montre la carte (`content_to_plane`).
+ pub content_cut: [f32; 4],
+ /// Remplissage du format sous un plan incliné : la carte penche dans son slot, fixe, et seul
+ /// le métrage bouge dedans. Son flou de mouvement reste donc par pixel (`screen_trail`).
+ pub fill_tilt: bool,
/// Point de focus du zoom (résolu : suivi curseur et rampe compris) en 0..1 DANS la coupe
/// dessinée `cut`, c'est-à-dire dans le plan que le mode 8 incline. Borné au plan : un focus
/// que le cover a rogné retombe sur le bord. C'est lui qui fixe `z_focus` (`depth_mb`).
@@ -2177,10 +2184,11 @@ impl FrameGeometry {
/// Incliné, le plan a bougé quand ses coins ont bougé : sans mouvement, ceux de `tilt_trail`
/// sont les siens au bit près, et le rendu reste celui d'avant, à l'octet.
///
- /// Pas sous un masque de bloc : la case ne bouge pas, seul le métrage bouge dedans, et le
- /// flou par pixel (modes 0 et 8) reste le bon.
+ /// Pas sous un masque de bloc ni sous le remplissage incliné : la case ou la carte ne bouge
+ /// pas, seul le métrage bouge dedans, et le flou par pixel (modes 0 et 8) reste le bon.
pub fn screen_trail(&self, render_px: [f32; 2]) -> bool {
- if self.mb_taps < 2.0 || self.mb_amount <= 0.001 || self.screen_mask.is_some() {
+ if self.mb_taps < 2.0 || self.mb_amount <= 0.001 || self.screen_mask.is_some() || self.fill_tilt
+ {
return false;
}
match self.screen_tilt_in(render_px) {
@@ -2760,14 +2768,31 @@ impl FrameGeometry {
(self.s_dst[0] + self.s_dst[2] * 0.5) * rw,
(self.s_dst[1] + self.s_dst[3] * 0.5) * rh,
];
+ // Sous le remplissage incliné, le plan ne montre que la fenêtre zoomée (`cut`) d'un
+ // métrage dont l'annotation donne les fractions (`content_cut`) : le grossissement et la
+ // boîte sont ceux du même écran à plat. Ailleurs, l'échelle vaut 1 au bit près.
+ let scale = self.content_scale();
+ let zoom_k = zoom_k * scale[1];
+ let content_px = [s_px[0] * scale[0], s_px[1] * scale[1]];
// La marge se prend en fraction du contenu, comme sur le chemin droit : `zoom_k` px de
// la boîte zoomée, soit un pixel de la boîte au repos. La projection l'emmène ensuite
// avec le contenu qu'elle borde.
let (mx, my) = (
- PRIVACY_MASK_PAD_PX * zoom_k / s_px[0].max(1.0),
- PRIVACY_MASK_PAD_PX * zoom_k / s_px[1].max(1.0),
+ PRIVACY_MASK_PAD_PX * zoom_k / content_px[0].max(1.0),
+ PRIVACY_MASK_PAD_PX * zoom_k / content_px[1].max(1.0),
);
- let (x0, y0, x1, y1) = (x - mx, y - my, x + w + mx, y + h + my);
+ let [x0, y0] = self.content_to_plane([x - mx, y - my]);
+ let [x1, y1] = self.content_to_plane([x + w + mx, y + h + my]);
+ // Rogné à la carte du remplissage : ce qu'elle ne montre pas n'a rien à cacher, et un
+ // masque hors d'elle flouterait le fond.
+ let (x0, y0, x1, y1) = if self.fill_tilt {
+ (x0.max(0.0), y0.max(0.0), x1.min(1.0), y1.min(1.0))
+ } else {
+ (x0, y0, x1, y1)
+ };
+ if x1 <= x0 || y1 <= y0 {
+ return None;
+ }
let at = |fx: f32, fy: f32| {
let (px, py) = quad.point_px(fx, fy);
[centre[0] + px, centre[1] + py]
@@ -2845,7 +2870,10 @@ impl FrameGeometry {
let s_px = [self.s_dst[2] * rw, self.s_dst[3] * rh];
if let Some(quad) = self.screen_tilt(s_px).filter(|_| self.tilted() && rw > 0.0 && rh > 0.0) {
let centre = self.screen_center_px(render_px);
+ // Les coins du métrage entier (`content_cut`), au-delà de la carte sous le
+ // remplissage incliné : le warp prolongé est exact, bilinéaire comme projectif.
let at = |fx: f32, fy: f32| {
+ let [fx, fy] = self.content_to_plane([fx, fy]);
let (px, py) = quad.point_px(fx, fy);
[(centre[0] + px) / rw, (centre[1] + py) / rh]
};
@@ -2860,7 +2888,29 @@ impl FrameGeometry {
/// Largeur sur hauteur du métrage dans son propre plan : celles du rect qu'incline le tilt.
pub fn footage_aspect(&self, render_px: [f32; 2]) -> f32 {
- self.s_dst[2] * render_px[0] / (self.s_dst[3] * render_px[1]).max(1e-6)
+ let scale = self.content_scale();
+ self.s_dst[2] * render_px[0] * scale[0] / (self.s_dst[3] * render_px[1] * scale[1]).max(1e-6)
+ }
+
+ /// Un point du métrage, en fractions de `content_cut` (le repère des annotations, des effets
+ /// et du gimbal), en fractions du plan dessiné (`cut`). L'identité, au bit près, hors du
+ /// remplissage incliné.
+ fn content_to_plane(&self, f: [f32; 2]) -> [f32; 2] {
+ if self.content_cut == self.cut {
+ return f;
+ }
+ let (c, k) = (self.content_cut, self.cut);
+ let map = |f: f32, a0: f32, a1: f32, b0: f32, b1: f32| (a0 + f * (a1 - a0) - b0) / (b1 - b0).max(1e-6);
+ [map(f[0], c[0], c[2], k[0], k[2]), map(f[1], c[1], c[3], k[1], k[3])]
+ }
+
+ /// Combien de fois le métrage dépasse le plan dessiné, par axe : 1 hors du remplissage incliné.
+ fn content_scale(&self) -> [f32; 2] {
+ if self.content_cut == self.cut {
+ return [1.0; 2];
+ }
+ let (c, k) = (self.content_cut, self.cut);
+ [(c[2] - c[0]) / (k[2] - k[0]).max(1e-6), (c[3] - c[1]) / (k[3] - k[1]).max(1e-6)]
}
}
@@ -3334,14 +3384,9 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
// coupe dessinée qui ne la contiendrait plus laisserait un trou dans le slot. Le masque du
// slot (`screen_mask`) rogne le reste.
let crop_cut = screen_source_rect(u_max, v_max, active_crop, 1.0, p.focus);
+ let flat_cut = if follow { crop_cut } else { cover(crop_cut, None) };
// Le remplissage incliné dessine la fenêtre zoomée elle-même : sa boîte est le slot.
- let cut = if fill_tilt {
- cut_ref
- } else if follow {
- crop_cut
- } else {
- cover(crop_cut, None)
- };
+ let cut = if fill_tilt { cut_ref } else { flat_cut };
// Ce que l'écran montre au repos : la fenêtre couverte, suivie ou non. Le curseur, les coins
// et l'ombre se mesurent sur elle, pas sur la coupe entière que le remplissage dessine.
let window = cover(crop_cut, follow_at(source_t));
@@ -3591,6 +3636,8 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
camera_prev,
padding_scale,
cut,
+ content_cut: flat_cut,
+ fill_tilt,
focus_plane,
// Sans scène (bench fixture), aucune zoom region, donc aucun tilt : rien à défocaliser.
depth_of_field: scene.is_some_and(|s| s.effects.depth_of_field),
@@ -6384,6 +6431,15 @@ mod tests {
/// `fill_plan`, avec ces `zoomRegions`.
fn fill_plan_with(follow: bool, pointer: Option<(f32, f32)>, zoom_regions: &str) -> FrameGeometry {
+ fill_plan_track(follow, pointer.map(|(x, y)| parked_track(x, y)), zoom_regions)
+ }
+
+ /// `fill_plan_with`, sur cette piste curseur.
+ fn fill_plan_track(
+ follow: bool,
+ track: Option<&'static crate::cursor::CursorTrack>,
+ zoom_regions: &str,
+ ) -> FrameGeometry {
let scene = Scene::from_json(&format!(
r##"{{
"clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],
@@ -6402,7 +6458,7 @@ mod tests {
let cfg = crate::config::all().pop().expect("au moins une config");
let mut input = golden_input(&scene, &cfg);
input.render_px = [1080.0, 1920.0];
- input.cursor = pointer.map(|(x, y)| parked_track(x, y));
+ input.cursor = track;
plan_frame(&input)
}
@@ -6507,6 +6563,70 @@ mod tests {
}
}
+ /// Sous le remplissage incliné, la carte ne montre que la fenêtre zoomée : un flou posé sur
+ /// le métrage (ses fractions sont celles de l'enregistrement entier) couvre toujours le
+ /// contenu qu'il cache, là où le curseur, passé par la coupe, le voit. Le gimbal de l'éditeur
+ /// (`footage_quad`) pose ce point au même endroit, et l'aspect est celui de l'enregistrement.
+ #[test]
+ fn a_privacy_mask_covers_its_content_on_a_tilted_filled_card() {
+ let render = [1080.0f32, 1920.0];
+ let p = (0.85f32, 0.8f32);
+ let uv_max = [1.0, 1080.0 / 1088.0];
+ for rotation in [r#""iso""#, ORBIT] {
+ let zoom = format!(r#"[{{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.85,"focusY":0.8,"rotation":{rotation}}}]"#);
+ let g = fill_plan_with(true, Some(p), &zoom);
+ assert!(g.fill_tilt, "{rotation} : garde, remplissage incliné");
+ let s_px = [g.s_dst[2] * render[0], g.s_dst[3] * render[1]];
+ let quad = g.screen_tilt(s_px).expect("incliné");
+ let c = g.screen_center_px(render);
+ // Où le contenu en `p` est dessiné, par la coupe comme le curseur.
+ let plane = cursor_plane_point(g.cut, uv_max, p).expect("garde : le point est sur la carte");
+ let (sx, sy) = quad.point_px(plane[0], plane[1]);
+ let seen = [c[0] + sx, c[1] + sy];
+
+ let mut a = blur_annotation("");
+ (a.w, a.h) = (0.04, 0.04);
+ (a.x, a.y) = (p.0 - 0.02, p.1 - 0.02);
+ let m = g.privacy_mask(&a, render).expect("masque");
+ let pts = m.warp.expect("incliné").map(|[x, y]| [m.dst[0] * render[0] + x, m.dst[1] * render[1] + y]);
+ let cross = |a: [f32; 2], b: [f32; 2], q: [f32; 2]| (b[0] - a[0]) * (q[1] - a[1]) - (b[1] - a[1]) * (q[0] - a[0]);
+ let sides: Vec<f32> = (0..4).map(|i| cross(pts[i], pts[(i + 1) % 4], seen)).collect();
+ assert!(
+ sides.iter().all(|&s| s >= 0.0) || sides.iter().all(|&s| s <= 0.0),
+ "{rotation} : le masque {pts:?} rate le contenu, dessiné en {seen:?}"
+ );
+ // Le grain grandit avec le contenu, comme à plat.
+ assert!(m.strength > 1.5, "{rotation} : force {}", m.strength);
+
+ // Le gimbal : le métrage entier, que la carte ne montre qu'en partie.
+ let f = g.footage_quad(render);
+ assert!(f.corners.iter().any(|q| q[0] < 0.0 || q[0] > 1.0 || q[1] < 0.0 || q[1] > 1.0), "{rotation} : gimbal réduit à la carte, {:?}", f.corners);
+ let ar = g.footage_aspect(render);
+ assert!((ar - 1920.0 / 1080.0).abs() < 1e-2, "{rotation} : aspect {ar}");
+ }
+ }
+
+ /// Le flou de mouvement de la carte inclinée du remplissage reste par pixel : la carte est
+ /// fixe dans son slot, seul le métrage bouge dedans. Le flou rigide (mode 18) l'étalait le
+ /// long du chemin du contenu, bords et coins compris.
+ #[test]
+ fn a_tilted_filled_card_keeps_a_per_pixel_motion_blur() {
+ let moving: &'static crate::cursor::CursorTrack = Box::leak(Box::new(crate::cursor::CursorTrack::new(
+ (0..=150).map(|i| (i as f32 / 30.0, 0.2 + 0.6 * i as f32 / 150.0, 0.5)).collect(),
+ vec![],
+ vec![],
+ )));
+ let render = [1080.0f32, 1920.0];
+ let zoom = format!(r#"[{{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.5,"focusY":0.5,"rotation":{ORBIT}}}]"#);
+ // Le pointeur en mouvement : la fenêtre suivie glisse d'une frame à l'autre.
+ let mut g = fill_plan_track(true, Some(moving), &zoom);
+ (g.mb_taps, g.mb_amount) = (8.0, 0.5);
+ assert!(g.fill_tilt, "garde : remplissage incliné");
+ assert_ne!(g.s_dst_prev, g.s_dst, "garde : le métrage bouge dans la carte");
+ assert!(!g.screen_trail(render), "flou rigide sur une carte fixe");
+ assert!(g.tilt_pixel_trail(render).is_some(), "le flou par pixel suit le métrage");
+ }
+
/// `slot_scene` à 1,5 s (zoom tenu), pointeur garé en `pointer` (la caméra en orbite le suit).
fn slot_plan(scene: &Scene, pointer: Option<(f32, f32)>) -> FrameGeometry {
let cfg = crate::config::all().pop().expect("au moins une config");
@@ -8033,6 +8153,8 @@ mod tests {
camera_prev: None,
padding_scale: 1.0,
cut: [0.0, 0.0, 1.0, 1.0],
+ content_cut: [0.0, 0.0, 1.0, 1.0],
+ fill_tilt: false,
focus_plane: [0.5, 0.5],
depth_of_field: false,
s_dst: [0.0, 0.0, 1.0, 1.0],