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): mask the screen with its slot in block layouts

EtienneLescotfb5d8665b55b
diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rs
index 2f5a6da92..69feaa8cd 100644
--- a/crates/compositor/src/compositor_linux.rs
+++ b/crates/compositor/src/compositor_linux.rs
@@ -1125,11 +1125,14 @@ impl Compositor {
/// `LayerCB` de l'ombre d'un ecran INCLINE (mode 12) : la penombre suit le
/// quadrilatere projete, pas son rect englobant. Port de
/// `compositor_macos::draw_quad_shadow`.
+ #[allow(clippy::too_many_arguments)]
fn quad_shadow_cb(
&self,
corners: &[(f32, f32); 4],
center_px: [f32; 2],
radius: f32,
+ // Le slot d'un layout en bloc, qui rogne le plan (`shadow_mask_fields`).
+ mask: Option<crate::frame_geometry::ScreenMask>,
spread: f32,
offset_px: [f32; 2],
opacity: f32,
@@ -1147,6 +1150,11 @@ impl Compositor {
let [tr0, tr1] = local(corners[1]);
let [br0, br1] = local(corners[2]);
let [bl0, bl1] = local(corners[3]);
+ let (mask_rect, mask_radius) = crate::frame_geometry::shadow_mask_fields(
+ mask,
+ [center_px[0] + min_x - spread, center_px[1] + min_y - spread],
+ [rw, rh],
+ );
LayerCB {
dst: [
(center_px[0] + min_x - spread + offset_px[0]) / rw,
@@ -1160,8 +1168,9 @@ impl Compositor {
color: [0.0, 0.0, 0.0, opacity],
fx: [tl0, tl1, tr0, tr1],
src_prev: [br0, br1, bl0, bl1],
+ dst_prev: mask_rect,
// Le spread vit ici et NON dans `fx.x` : `fx` porte deja les coins.
- mb: [0.0, spread, 1.0, 0.0],
+ mb: [0.0, spread, 1.0, mask_radius],
..Default::default()
}
}
@@ -2067,18 +2076,23 @@ impl Compositor {
// `color.z` au mode 8) : l'arrondi du haut se fait par le cadre. 0 sans fenetre.
let top_lift = g.screen_top_lift_px([rw, rh]);
let screen_layer = match tilt.as_ref() {
- None => LayerCB {
- dst: g.s_dst,
- src: g.cut,
- quad_px: s_px,
- radius_px: g.s_radius,
- mode: 0.0,
- color: [1.0, 1.0, 1.0, 1.0],
- src_prev: g.cut,
- dst_prev: g.s_dst_prev,
- mb: [g.mb_taps, g.mb_amount, top_lift, square_top],
- ..Default::default()
- },
+ None => {
+ // Sous le masque d'un layout en bloc, rogne au slot (`mask_flat_screen`).
+ let (dst, src, quad_px, radius_px) =
+ g.mask_flat_screen(g.s_dst, g.cut, s_px, g.s_radius, [rw, rh]);
+ LayerCB {
+ dst,
+ src,
+ quad_px,
+ radius_px,
+ mode: 0.0,
+ color: [1.0, 1.0, 1.0, 1.0],
+ src_prev: g.cut,
+ dst_prev: g.s_dst_prev,
+ mb: [g.mb_taps, g.mb_amount, top_lift, square_top],
+ ..Default::default()
+ }
+ }
// Mode 8, partage avec Windows et macOS (`tilted_screen_cb`).
Some(quad) => tilted_screen_cb(
quad,
@@ -2090,6 +2104,7 @@ impl Compositor {
top_lift,
dof,
[rw, rh],
+ g.screen_mask,
),
};
// Bind group construit AVANT le pass (doit vivre pendant tout le pass) ;
@@ -2145,9 +2160,8 @@ impl Compositor {
ShadowCaster::Upright { dst, size_px, radius } => {
self.shadow_cb(dst, size_px, radius, spread, offset, opacity)
}
- ShadowCaster::Tilted { corners, center_px, radius } => {
- self.quad_shadow_cb(&corners, center_px, radius, spread, offset, opacity)
- }
+ ShadowCaster::Tilted { corners, center_px, radius, mask } => self
+ .quad_shadow_cb(&corners, center_px, radius, mask, spread, offset, opacity),
},
};
self.make_bind(&cb, None, &dummy)
diff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rs
index 3dd550ce0..463fb02b2 100644
--- a/crates/compositor/src/compositor_macos.rs
+++ b/crates/compositor/src/compositor_macos.rs
@@ -1212,6 +1212,8 @@ impl Compositor {
corners: &[(f32, f32); 4],
center_px: [f32; 2],
radius: f32,
+ // Le slot d'un layout en bloc, qui rogne le plan (`shadow_mask_fields`).
+ mask: Option<crate::frame_geometry::ScreenMask>,
spread: f32,
offset_px: [f32; 2],
opacity: f32,
@@ -1229,6 +1231,11 @@ impl Compositor {
let [tr0, tr1] = local(corners[1]);
let [br0, br1] = local(corners[2]);
let [bl0, bl1] = local(corners[3]);
+ let (mask_rect, mask_radius) = crate::frame_geometry::shadow_mask_fields(
+ mask,
+ [center_px[0] + min_x - spread, center_px[1] + min_y - spread],
+ [rw, rh],
+ );
self.draw_solid(
enc,
&LayerCB {
@@ -1244,7 +1251,8 @@ impl Compositor {
color: [0.0, 0.0, 0.0, opacity],
fx: [tl0, tl1, tr0, tr1],
src_prev: [br0, br1, bl0, bl1],
- mb: [0.0, spread, 1.0, 0.0],
+ dst_prev: mask_rect,
+ mb: [0.0, spread, 1.0, mask_radius],
..Default::default()
},
);
@@ -1265,6 +1273,8 @@ impl Compositor {
// Sous le chrome de fenêtre : la remontée de son contour intérieur au-dessus de
// l'écran (`screen_top_lift_px`), qui carre les coins hauts. 0 ailleurs.
top_lift: f32,
+ // Le slot d'un layout en bloc, qui rogne le plan (`FrameGeometry::screen_mask`).
+ mask: Option<crate::frame_geometry::ScreenMask>,
y: &metal::Texture,
uv: &metal::Texture,
dof_pyramid: Option<&metal::Texture>,
@@ -1284,6 +1294,7 @@ impl Compositor {
top_lift,
dof_pyramid.is_some(),
render_px,
+ mask,
);
self.draw_video(enc, &cb, y, uv);
}
@@ -2199,8 +2210,8 @@ impl Compositor {
ShadowCaster::Upright { dst, size_px, radius } => {
self.draw_shadow(enc, dst, size_px, radius, spread, offset, opacity)
}
- ShadowCaster::Tilted { corners, center_px, radius } => self.draw_quad_shadow(
- enc, &corners, center_px, radius, spread, offset, opacity,
+ ShadowCaster::Tilted { corners, center_px, radius, mask } => self.draw_quad_shadow(
+ enc, &corners, center_px, radius, mask, spread, offset, opacity,
),
}
}
@@ -2212,14 +2223,17 @@ impl Compositor {
let square_top = g.screen_square_top();
let top_lift = g.screen_top_lift_px([rw, rh]);
let [su0, sv0, su1, sv1] = g.cut;
+ // Sous le masque d'un layout en bloc, rogné au slot (`FrameGeometry::mask_flat_screen`).
+ let (dst, src, quad_px, radius_px) =
+ g.mask_flat_screen(g.s_dst, [su0, sv0, su1, sv1], s_px, g.s_radius, [rw, rh]);
match tilt.as_ref() {
None => self.draw_video(
enc,
&LayerCB {
- dst: g.s_dst,
- src: [su0, sv0, su1, sv1],
- quad_px: s_px,
- radius_px: g.s_radius,
+ dst,
+ src,
+ quad_px,
+ radius_px,
mode: 0.0,
color: [0.0, 0.0, 0.0, 1.0],
src_prev: [su0, sv0, su1, sv1],
@@ -2239,6 +2253,7 @@ impl Compositor {
g.focus_plane,
g.s_radius,
top_lift,
+ g.screen_mask,
&sy,
&suv,
dof_pyramid.as_ref(),
diff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rs
index da983553b..621986b58 100644
--- a/crates/compositor/src/compositor_windows.rs
+++ b/crates/compositor/src/compositor_windows.rs
@@ -1694,11 +1694,14 @@ impl Compositor {
/// `radius` est le rayon des coins du PLAN, réutilisé tel quel : la projection l'étire de
/// ±10 % selon l'endroit du bord, écart invisible sur une ombre floue, alors qu'une ombre à
/// coins vifs derrière un écran arrondi dépasse en pointe et se voit tout de suite.
+ #[allow(clippy::too_many_arguments)]
pub unsafe fn draw_quad_shadow(
&self,
corners: &[(f32, f32); 4],
center_px: [f32; 2],
radius: f32,
+ // Le slot d'un layout en bloc, qui rogne le plan (`shadow_mask_fields`).
+ mask: Option<crate::frame_geometry::ScreenMask>,
spread: f32,
offset_px: [f32; 2],
opacity: f32,
@@ -1719,6 +1722,11 @@ impl Compositor {
let [tr0, tr1] = local(corners[1]);
let [br0, br1] = local(corners[2]);
let [bl0, bl1] = local(corners[3]);
+ let (mask_rect, mask_radius) = crate::frame_geometry::shadow_mask_fields(
+ mask,
+ [center_px[0] + min_x - spread, center_px[1] + min_y - spread],
+ [self.rw(), self.rh()],
+ );
self.draw_solid(&LayerCB {
dst: [
origin_x / self.rw(),
@@ -1732,7 +1740,8 @@ impl Compositor {
color: [0.0, 0.0, 0.0, opacity],
fx: [tl0, tl1, tr0, tr1],
src_prev: [br0, br1, bl0, bl1],
- mb: [0.0, spread, 1.0, 0.0],
+ dst_prev: mask_rect,
+ mb: [0.0, spread, 1.0, mask_radius],
..Default::default()
});
}
@@ -1937,9 +1946,8 @@ impl Compositor {
self.draw_shadow(dst, size_px, radius, spread, offset, opacity)
}
// Même rayon que le plan incliné lui-même (cf. le dessin du mode 8).
- ShadowCaster::Tilted { corners, center_px, radius } => {
- self.draw_quad_shadow(&corners, center_px, radius, spread, offset, opacity)
- }
+ ShadowCaster::Tilted { corners, center_px, radius, mask } => self
+ .draw_quad_shadow(&corners, center_px, radius, mask, spread, offset, opacity),
}
}
}
@@ -1973,18 +1981,27 @@ impl Compositor {
top_lift,
dof,
render_px,
+ g.screen_mask,
),
&sy,
&suv,
);
self.ctx.PSSetShaderResources(2, Some(&[None]));
} else {
+ // Sous le masque d'un layout en bloc, rogné au slot (`FrameGeometry::mask_flat_screen`).
+ let (dst, src, quad_px, radius_px) = g.mask_flat_screen(
+ s_dst,
+ [su0, sv0, su0 + 2.0 * hu, sv0 + 2.0 * hv],
+ s_px,
+ s_radius,
+ render_px,
+ );
self.draw_video(
&LayerCB {
- dst: s_dst,
- src: [su0, sv0, su0 + 2.0 * hu, sv0 + 2.0 * hv],
- quad_px: s_px,
- radius_px: s_radius,
+ dst,
+ src,
+ quad_px,
+ radius_px,
mode: 0.0,
color: [0.0, 0.0, 0.0, 1.0],
src_prev: [su0_p, sv0_p, su0_p + 2.0 * hu_p, sv0_p + 2.0 * hv_p],
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rs
index 77f1b0ef2..1688397ae 100644
--- a/crates/compositor/src/frame_geometry.rs
+++ b/crates/compositor/src/frame_geometry.rs
@@ -938,7 +938,24 @@ pub enum ShadowCaster {
/// Rect droit (mode 2) : `dst` en fractions de sortie, `size_px` sa taille, `radius` en px.
Upright { dst: [f32; 4], size_px: [f32; 2], radius: f32 },
/// Quad incliné (mode 12) : coins TL, TR, BR, BL relatifs à `center_px`, rayon du plan.
- Tilted { corners: [(f32, f32); 4], center_px: [f32; 2], radius: f32 },
+ /// `mask` : le slot d'un layout en bloc, qui rogne le plan — l'ombre est alors celle de
+ /// leur intersection, ce qu'on voit (`shadow_mask_fields`).
+ Tilted { corners: [(f32, f32); 4], center_px: [f32; 2], radius: f32, mask: Option<ScreenMask> },
+}
+
+/// Les champs du mode 12 qui rognent l'ombre d'un plan incliné au slot qui le masque : `dst_prev`
+/// = le slot en px LOCAUX à la boîte de l'ombre (x0, y0, x1, y1), `mb.w` = le rayon de ses coins.
+/// `origin_px` : l'origine de ce repère local, en px de sortie, décalage de l'ombre NON compris —
+/// le slot et le plan portent le même. Des zéros sans masque : le shader n'en fait rien.
+pub fn shadow_mask_fields(
+ mask: Option<ScreenMask>,
+ origin_px: [f32; 2],
+ render_px: [f32; 2],
+) -> ([f32; 4], f32) {
+ let Some(m) = mask else { return ([0.0; 4], 0.0) };
+ let [x, y, w, h] = m.rect;
+ let (x0, y0) = (x * render_px[0] - origin_px[0], y * render_px[1] - origin_px[1]);
+ ([x0, y0, x0 + w * render_px[0], y0 + h * render_px[1]], m.radius_px)
}
/// Rect [x,y,w,h] normalisé d'un sprite de curseur de taille `w`×`h` dont le pivot `hotspot`
/// (fraction 0..1 de l'image) doit tomber exactement sur `center`.
@@ -1129,6 +1146,10 @@ pub const CAMERA_LIGHT_GAIN: f32 = 0.2;
/// porte l'éclairage, `1 + color.x·(s − 0,5) + color.y·(t − 0,5)` : la lampe de la caméra, fixe
/// dans le monde comme l'œil, éclaire un peu plus le côté proche. Nuls sous un angle fixe, dont le
/// rendu reste celui d'avant à l'octet.
+///
+/// Sous le masque d'un layout en bloc (`mask`) : le plan penche DANS le slot, qui le rogne. Il est
+/// dessiné dans le rect du slot au lieu de sa bbox, et `color.w` porte le rayon des coins du slot,
+/// que le shader applique à ce rect. Nul sans masque, comme avant.
#[allow(clippy::too_many_arguments)]
pub fn tilted_screen_cb(
quad: &crate::regions::TiltedQuad,
@@ -1140,6 +1161,7 @@ pub fn tilted_screen_cb(
top_lift_px: f32,
dof: bool,
render_px: [f32; 2],
+ mask: Option<ScreenMask>,
) -> LayerCB {
let [rw, rh] = render_px;
let corners = quad.corners;
@@ -1172,7 +1194,7 @@ pub fn tilted_screen_cb(
} else {
[0.0; 4]
};
- LayerCB {
+ let mut cb = LayerCB {
dst: [(center_px[0] + min_x) / rw, (center_px[1] + min_y) / rh, bbox_w / rw, bbox_h / rh],
src,
quad_px: [bbox_w, bbox_h],
@@ -1189,7 +1211,12 @@ pub fn tilted_screen_cb(
// Gradient de profondeur du plan, profondeur du focus et `k` (`depth_mb`).
mb: quad.depth_mb(s_px, focus_plane, dof),
..Default::default()
+ };
+ if let Some(mask) = mask {
+ reframe_warped(&mut cb, mask.rect, render_px);
+ cb.color[3] = mask.radius_px;
}
+ cb
}
/// `LayerCB` d'une ombre portée par un quadrilatère (mode 12). `corners` (TL, TR, BR, BL) en px
@@ -1647,6 +1674,48 @@ pub struct FrameGeometry {
/// déjà la boîte rétrécie, et `s_radius` le rayon des coins de l'écran — des seuls coins BAS
/// sous une barre de titre (fenêtre, navigateur), des quatre pour les autres appareils.
pub window_frame: Option<WindowFrame>,
+ /// Layouts en bloc : le slot de l'écran, un conteneur qui le MASQUE (cf. `ScreenMask`).
+ /// `None` ailleurs, et le rendu est celui d'avant, à l'octet.
+ pub screen_mask: Option<ScreenMask>,
+}
+
+/// Le conteneur d'un layout en bloc (côte à côte, haut/bas) : un masque fixe, overflow hidden.
+///
+/// L'écran y garde la géométrie de tous les layouts — le zoom dans la boîte (#179), la 3D sur le
+/// métrage — et seul son DESSIN est rogné au slot. Sans lui, la boîte zoomée débordait sur la
+/// caméra et dans l'espace qui les sépare, et le bloc ne tenait plus. Le masque, lui, ne zoome
+/// ni ne penche jamais : le layout garde son rect et ses coins, et son ombre est la sienne.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct ScreenMask {
+ /// Le slot, en fractions de la sortie : `layout.screenRect`, que le zoom ne touche pas.
+ pub rect: [f32; 4],
+ /// Le rayon de ses coins, en px du render target : celui de l'écran au repos.
+ pub radius_px: f32,
+}
+
+impl ScreenMask {
+ /// `dst` rogné au slot, en fractions de la sortie. `None` s'il n'en reste rien ; `dst` tel
+ /// quel, à l'octet, s'il y tient déjà (une intersection recalculée en différerait d'un ulp).
+ fn clip(&self, dst: [f32; 4]) -> Option<[f32; 4]> {
+ let [x, y, w, h] = self.rect;
+ if dst[0] >= x && dst[1] >= y && dst[0] + dst[2] <= x + w && dst[1] + dst[3] <= y + h {
+ return Some(dst);
+ }
+ let r = intersect_rect(dst, self.rect);
+ (r[2] > 0.0 && r[3] > 0.0).then_some(r)
+ }
+}
+
+/// Redessine un calque WARPÉ (modes 8 et 16 : coins TL/TR dans `fx`, BR/BL dans `src_prev`, en px
+/// locaux à `dst`) dans une autre boîte `dst`. Le warp ne dépend pas de la boîte de dessin, qui ne
+/// fait que borner les pixels rastérisés : il suffit de reporter les coins dans son repère.
+fn reframe_warped(cb: &mut LayerCB, dst: [f32; 4], render_px: [f32; 2]) {
+ let shift = [(dst[0] - cb.dst[0]) * render_px[0], (dst[1] - cb.dst[1]) * render_px[1]];
+ for c in [&mut cb.fx, &mut cb.src_prev] {
+ *c = [c[0] - shift[0], c[1] - shift[1], c[2] - shift[0], c[3] - shift[1]];
+ }
+ cb.dst = dst;
+ cb.quad_px = [dst[2] * render_px[0], dst[3] * render_px[1]];
}
/// Rect de destination d'une annotation dans un rect d'ancrage, en fractions de la sortie.
@@ -1820,7 +1889,16 @@ impl FrameGeometry {
/// qu'un quad plat ne sait pas porter.
pub fn shadow_caster(&self, render_px: [f32; 2]) -> ShadowCaster {
let center_px = self.screen_center_px(render_px);
- match (&self.window_frame, self.screen_tilt_in(render_px)) {
+ let tilt = self.screen_tilt_in(render_px);
+ // Sous le masque d'un layout en bloc, l'ombre est celle de ce qu'on voit. Droite, la boîte
+ // zoomée couvre tout le slot : c'est le slot, qui ne zoome pas. Inclinée, le plan rogné
+ // par le slot (`mask` du quad, plus bas).
+ if let (Some(mask), None) = (self.screen_mask, &tilt) {
+ let dst = mask.rect;
+ let size_px = [dst[2] * render_px[0], dst[3] * render_px[1]];
+ return ShadowCaster::Upright { dst, size_px, radius: mask.radius_px };
+ }
+ match (&self.window_frame, tilt) {
(None, None) => ShadowCaster::Upright {
dst: self.s_dst,
size_px: [self.s_dst[2] * render_px[0], self.s_dst[3] * render_px[1]],
@@ -1830,6 +1908,7 @@ impl FrameGeometry {
corners: quad.corners,
center_px,
radius: self.s_radius * quad.scale,
+ mask: self.screen_mask,
},
(Some(frame), None) => {
let [ml, mt, mr, mb] = frame.margins;
@@ -1848,17 +1927,46 @@ impl FrameGeometry {
}
(Some(frame), Some(_)) => {
let (corners, scale, _) = self.window_frame_corners(frame.margins, render_px);
- ShadowCaster::Tilted { corners, center_px, radius: frame.radius[0] * scale }
+ ShadowCaster::Tilted { corners, center_px, radius: frame.radius[0] * scale, mask: None }
}
}
}
+ /// L'écran droit (mode 0) sous le masque d'un layout en bloc : `dst` rogné au slot, `src`
+ /// d'autant (même mapping image→écran), et les coins du slot. Sans masque, les valeurs du
+ /// backend repartent telles quelles, à l'octet. Le flou de mouvement n'a rien à suivre : il
+ /// lit la frame précédente par `dst_prev`/`src_prev`, que le masque ne touche pas.
+ pub fn mask_flat_screen(
+ &self,
+ dst: [f32; 4],
+ src: [f32; 4],
+ quad_px: [f32; 2],
+ radius_px: f32,
+ render_px: [f32; 2],
+ ) -> ([f32; 4], [f32; 4], [f32; 2], f32) {
+ let Some(mask) = self.screen_mask else { return (dst, src, quad_px, radius_px) };
+ let clipped = intersect_rect(dst, mask.rect);
+ let u = |x: f32| src[0] + (x - dst[0]) / dst[2] * (src[2] - src[0]);
+ let v = |y: f32| src[1] + (y - dst[1]) / dst[3] * (src[3] - src[1]);
+ let [x0, y0, w, h] = clipped;
+ (
+ clipped,
+ [u(x0), v(y0), u(x0 + w), v(y0 + h)],
+ [w * render_px[0], h * render_px[1]],
+ mask.radius_px,
+ )
+ }
+
/// Décalage de l'ombre portée de l'écran, en px de sortie : vers le bas sous un écran droit
/// ou un angle fixe (inchangé) ; sous la caméra réelle, le long de la lumière qui éclaire aussi
/// la flèche modélisée (`MODEL_LIGHT`), pour que les deux ombres tombent du même côté. La
- /// direction glisse avec le poids de la caméra : aucun saut à l'entrée du zoom.
+ /// direction glisse avec le poids de la caméra : aucun saut à l'entrée du zoom. Sous le masque
+ /// d'un layout en bloc, l'ombre est celle du slot, que la caméra ne fait pas tourner.
pub fn screen_shadow_offset(&self) -> [f32; 2] {
let off = SCREEN_SHADOW_OFFSET_FRAC * self.frame_min_px;
+ if self.screen_mask.is_some() {
+ return [0.0, off];
+ }
let Some(pose) = self.camera else { return [0.0, off] };
let (lx, ly) = (-MODEL_LIGHT[0], -MODEL_LIGHT[1]);
let n = lx.hypot(ly);
@@ -2121,11 +2229,21 @@ impl FrameGeometry {
upright
};
let dst = pad_rect(rect, render_px, PRIVACY_MASK_PAD_PX * zoom_k);
+ // Sous le masque d'un layout en bloc, rien n'est dessiné hors du slot : rien à y
+ // cacher, et un masque y flouterait la caméra.
+ let (dst, clipped) = match self.screen_mask {
+ Some(m) => {
+ let c = m.clip(dst)?;
+ (c, c != dst)
+ }
+ None => (dst, false),
+ };
let mut mask = PrivacyMask::upright(dst, render_px, zoom_k);
// Un ovale inscrit dans la boîte ÉLARGIE ne contient plus l'ovale courant dès que
// les deux centres diffèrent : son bord laisserait passer une frange du secret. On
- // retombe alors sur le rectangle, comme le tracé libre.
- mask.oval_ok = !trail;
+ // retombe alors sur le rectangle, comme le tracé libre. Même chose dans la boîte
+ // ROGNÉE par le slot.
+ mask.oval_ok = !trail && !clipped;
return Some(mask);
}
@@ -2159,8 +2277,18 @@ impl FrameGeometry {
max_y = max_y.max(py);
}
// Plancher d'un pixel : un masque très fin ferait diverger le warp inverse.
- let quad_px = [(max_x - min_x).max(1.0), (max_y - min_y).max(1.0)];
- let local = pts.map(|[px, py]| [px - min_x, py - min_y]);
+ let mut quad_px = [(max_x - min_x).max(1.0), (max_y - min_y).max(1.0)];
+ let mut local = pts.map(|[px, py]| [px - min_x, py - min_y]);
+ let mut dst = [min_x / rw, min_y / rh, quad_px[0] / rw, quad_px[1] / rh];
+ // Sous le masque d'un layout en bloc, dessiné dans la part du slot qu'il couvre : les
+ // coins passent dans le repère de cette boîte, le warp (et son ovale) ne bouge pas.
+ if let Some(m) = self.screen_mask {
+ let c = m.clip(dst)?;
+ let shift = [(c[0] - dst[0]) * rw, (c[1] - dst[1]) * rh];
+ local = local.map(|[px, py]| [px - shift[0], py - shift[1]]);
+ quad_px = [c[2] * rw, c[3] * rh];
+ dst = c;
+ }
// La perspective grossit localement le côté proche : la force suit l'arête la plus
// agrandie par rapport au rect droit zoomé, pour que nulle part le masque ne soit plus
// fin, rapporté au contenu, qu'au repos.
@@ -2171,7 +2299,7 @@ impl FrameGeometry {
.max(len(pts[0], pts[3]) / eh)
.max(len(pts[1], pts[2]) / eh);
Some(PrivacyMask {
- dst: [min_x / rw, min_y / rh, quad_px[0] / rw, quad_px[1] / rh],
+ dst,
quad_px,
warp: Some(local),
projective: quad.projective,
@@ -2241,6 +2369,13 @@ fn union_rect(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
[x0, y0, x1 - x0, y1 - y0]
}
+/// Vide (largeur ou hauteur nulle) quand les deux rects ne se touchent pas.
+fn intersect_rect(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
+ let (x0, y0) = (a[0].max(b[0]), a[1].max(b[1]));
+ let (x1, y1) = ((a[0] + a[2]).min(b[0] + b[2]), (a[1] + a[3]).min(b[1] + b[3]));
+ [x0, y0, (x1 - x0).max(0.0), (y1 - y0).max(0.0)]
+}
+
fn pad_rect(r: [f32; 4], render_px: [f32; 2], pad_px: f32) -> [f32; 4] {
let (px, py) = (pad_px / render_px[0], pad_px / render_px[1]);
[r[0] - px, r[1] - py, r[2] + 2.0 * px, r[3] + 2.0 * py]
@@ -2676,7 +2811,6 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
// la boîte, pas suivre le cadre.
let frame_min_px = rw.min(rh);
let s_px = [s_dst[2] * rw, s_dst[3] * rh];
- let s_min_px = s_px[0].min(s_px[1]);
let app_screen_radius_frac = scene.and_then(|s| s.layout.screen_radius_frac);
let scene_roundness_frac = scene.map(|s| s.effects.roundness_frac);
// ---- Le rayon des coins, en UN seul endroit ----
@@ -2695,20 +2829,33 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
// chaque bordure garde son épaisseur tout autour de chaque coin. Sous le chrome de
// fenêtre, les coins HAUTS du métrage restent carrés, à ras de la barre : l'arrondi du
// haut se fait une seule fois, par le cadre (`screen_square_top`, `screen_top_lift_px`).
- let outer_radius = match (cfg.rounded, app_screen_radius_frac, scene_roundness_frac) {
+ let outer_radius_of = |s_px: [f32; 2]| match (cfg.rounded, app_screen_radius_frac, scene_roundness_frac) {
(false, _, _) => 0.0,
(true, _, _) if frame_kind != crate::scene::SceneFrame::None => {
let t = scene.map(roundness_slider_position).unwrap_or(0.0);
t * frame_roundness_cap(frame_kind) * frame_unit_px(s_px, [rw, rh])
}
// Preset en bloc : le rayon appartient à la boîte écran (parité exacte avec la caméra).
- (true, Some(f), _) => f * s_min_px,
+ (true, Some(f), _) => f * s_px[0].min(s_px[1]),
// Scène sans rayon imposé : slider Roundness, relatif au cadre.
(true, None, Some(f)) => f * frame_min_px,
// Fixture/bench (pas de scène) : chemin inspector historique, inchangé.
(true, None, None) => p.screen.radius * lp.radius_scale,
};
- let s_radius = screen_corner_radius_px(outer_radius, s_px);
+ let s_radius = screen_corner_radius_px(outer_radius_of(s_px), s_px);
+ // Layouts en bloc : le slot masque l'écran (`ScreenMask`), avec les coins de l'écran AU
+ // REPOS — la boîte, elle, grandit avec le zoom. `screen_cover` est le drapeau du slot :
+ // l'app ne le lève que pour ces deux layouts, et seulement sur un clip qui a une caméra.
+ // Pas sous un cadre : il déborde du slot au repos, le masque le couperait.
+ let screen_mask = (scene.is_some_and(|s| s.layout.screen_cover)
+ && frame_kind == crate::scene::SceneFrame::None)
+ .then(|| {
+ let slot_px = [s_base[2] * rw, s_base[3] * rh];
+ ScreenMask {
+ rect: s_base,
+ radius_px: screen_corner_radius_px(outer_radius_of(slot_px), slot_px),
+ }
+ });
let window_frame = frame_margins.map(|margins| {
let (l, t, b) = (margins[0] * s_px[0], margins[1] * s_px[1], margins[3] * s_px[1]);
// La fenêtre n'a qu'un rayon (mode 14) : celui de ses coins BAS, où le métrage s'arrondit
@@ -2781,6 +2928,7 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
w_radius,
shape_fade,
window_frame,
+ screen_mask,
}
}
@@ -3047,6 +3195,11 @@ pub fn plan_cursor(g: &FrameGeometry, input: &CursorPlanInput) -> Option<CursorP
Some(s) if s.cursor.clip_to_bounds => cursor_bounds,
_ => [-1.0, -1.0, 3.0, 3.0],
};
+ // Le curseur est sur le métrage : sous le masque d'un layout en bloc, le slot le rogne aussi.
+ let clip = match g.screen_mask {
+ Some(m) => intersect_rect(clip, m.rect),
+ None => clip,
+ };
// L'impact : un anneau par clic récent, centré sur son point BRUT, là où la pointe se pose.
let strength = (lp.cursor_bounce_scale / MODEL_CLICK_BOUNCE_REF).clamp(0.0, 2.0);
@@ -3057,7 +3210,12 @@ pub fn plan_cursor(g: &FrameGeometry, input: &CursorPlanInput) -> Option<CursorP
.clicks_with_points(input.t - IMPACT_DELAY_S - IMPACT_S, input.t - IMPACT_DELAY_S)
.filter_map(|(tc, p)| {
let impact = impact_at(input.t - tc, strength)?;
- cursor_impact_cb(place(Some(p), g.s_dst)?, half_px, impact, alpha)
+ let mut cb = cursor_impact_cb(place(Some(p), g.s_dst)?, half_px, impact, alpha)?;
+ if let Some(m) = g.screen_mask {
+ let dst = m.clip(cb.dst)?;
+ reframe_warped(&mut cb, dst, [rw, rh]);
+ }
+ Some(cb)
})
.collect()
} else {
@@ -3814,6 +3972,7 @@ mod tests {
corners: q.corners,
center_px: none.screen_center_px(RENDER),
radius: none.s_radius * q.scale,
+ mask: None,
},
};
assert_eq!(none.shadow_caster(RENDER), expected);
@@ -3899,7 +4058,7 @@ mod tests {
let g = framed_plan(&framed_scene(r#","frame":"window-light""#, preset, 1.0, false));
let wf = g.window_frame.expect("un cadre");
let quad = g.screen_tilt_in(RENDER).expect("incliné");
- let ShadowCaster::Tilted { corners: frame, center_px, radius } = g.shadow_caster(RENDER) else {
+ let ShadowCaster::Tilted { corners: frame, center_px, radius, .. } = g.shadow_caster(RENDER) else {
panic!("un cadre incliné porte une ombre inclinée");
};
assert_eq!(center_px, g.screen_center_px(RENDER));
@@ -4100,6 +4259,7 @@ mod tests {
g.screen_top_lift_px(RENDER),
false,
RENDER,
+ g.screen_mask,
)
};
for (name, _) in DEVICES {
@@ -4987,6 +5147,213 @@ mod tests {
assert!((m.strength - 2.0).abs() < 1e-3, "force {} au lieu de 2", m.strength);
}
+ /// Le bloc « côte à côte » tel que `computeCompositeLayout` le résout : l'écran dans un slot
+ /// au ratio de la capture, la caméra à côté, `screenCover`. Zoom `zoom` sous `rotation`, focus
+ /// décentré (0.3, 0.6). `cover: false` rend le même bloc sans slot, comme les autres layouts.
+ fn slot_scene(rotation: &str, zoom: f32, cover: bool) -> Scene {
+ Scene::from_json(&format!(
+ r##"{{
+ "clips":[{{"screenPath":"/s.mp4","webcamPath":"/w.mp4","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],
+ "layout":{{"preset":"dual-frame","webcamSize":0.25,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,
+ "webcamReactiveZoom":false,"screenRect":{{"x":0.1,"y":0.25,"width":0.55,"height":0.55}},
+ "webcamRect":{{"x":0.666,"y":0.25,"width":0.234,"height":0.55}},
+ "screenRadiusFrac":0.04,"webcamRadiusFrac":0.04,"screenCover":{cover}}},
+ "effects":{{"padding":0.5,"blur":false,"shadow":0.5,"roundnessFrac":0.03,"motionBlur":0}},
+ "background":{{"kind":"color","color":"#1e1e2e"}},
+ "zoomRegions":[{{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":{zoom},"focusX":0.3,"focusY":0.6,"rotation":{rotation}}}],
+ "cursor":{{"show":true,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":1,"clipToBounds":false,"theme":"default"}},
+ "cropByClip":[null],
+ "output":{{"width":1920,"height":1080,"fps":60}}
+ }}"##
+ ))
+ .expect("scène côte à côte")
+ }
+
+ /// Le `screenRect` de `slot_scene`.
+ const SLOT: [f32; 4] = [0.1, 0.25, 0.55, 0.55];
+
+ /// Une piste où le pointeur reste garé en (x, y).
+ fn parked_track(x: f32, y: f32) -> &'static crate::cursor::CursorTrack {
+ Box::leak(Box::new(crate::cursor::CursorTrack::new(
+ (0..=150).map(|i| (i as f32 / 30.0, x, y)).collect(),
+ vec![],
+ vec![],
+ )))
+ }
+
+ /// `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");
+ let mut input = golden_input(scene, &cfg);
+ input.render_px = RENDER;
+ input.cursor = pointer.map(|(x, y)| parked_track(x, y));
+ plan_frame(&input)
+ }
+
+ /// Côte à côte et haut/bas : le slot MASQUE l'écran (overflow hidden). L'écran garde la
+ /// géométrie de tous les layouts — sa boîte zoomée déborde — et seul son dessin est rogné au
+ /// slot, coins du slot compris, sans déplacer un pixel. L'ombre est celle du slot.
+ #[test]
+ fn a_block_layout_masks_its_screen_with_the_slot() {
+ let rest = slot_plan(&slot_scene("null", 1.0, true), None);
+ let g = slot_plan(&slot_scene("null", 2.0, true), None);
+ let free = slot_plan(&slot_scene("null", 2.0, false), None);
+ assert_eq!(free.screen_mask, None, "sans slot, pas de masque");
+ let mask = g.screen_mask.expect("un layout en bloc masque son écran");
+ assert_eq!(mask.rect, SLOT);
+ assert!((mask.radius_px - rest.s_radius).abs() < 1e-3, "coins {} au lieu de {}", mask.radius_px, rest.s_radius);
+
+ // La géométrie de partout : la boîte zoomée est celle du même bloc sans slot, et déborde.
+ for k in 0..4 {
+ assert!((g.s_dst[k] - free.s_dst[k]).abs() < 1e-3, "{:?} au lieu de {:?}", g.s_dst, free.s_dst);
+ }
+ assert!(!contains(SLOT, g.s_dst, 1e-3), "garde : la boîte zoomée doit déborder, {:?}", g.s_dst);
+
+ // Le dessin, lui, est rogné au slot, avec ses coins.
+ let s_px = [g.s_dst[2] * RENDER[0], g.s_dst[3] * RENDER[1]];
+ let (dst, src, quad_px, radius) = g.mask_flat_screen(g.s_dst, g.cut, s_px, g.s_radius, RENDER);
+ for k in 0..4 {
+ assert!((dst[k] - SLOT[k]).abs() < 1e-6, "dessin {dst:?} au lieu du slot");
+ }
+ assert_eq!(quad_px, [dst[2] * RENDER[0], dst[3] * RENDER[1]]);
+ assert_eq!(radius, mask.radius_px);
+ // Rogner ne déplace aucun pixel : même mapping image→écran, coins du slot compris.
+ let uv = |d: [f32; 4], s: [f32; 4], x: f32, y: f32| {
+ [s[0] + (x - d[0]) / d[2] * (s[2] - s[0]), s[1] + (y - d[1]) / d[3] * (s[3] - s[1])]
+ };
+ for (x, y) in [(0.1, 0.25), (0.65, 0.8), (0.3, 0.5)] {
+ let (a, b) = (uv(dst, src, x, y), uv(g.s_dst, g.cut, x, y));
+ assert!((a[0] - b[0]).abs() < 1e-5 && (a[1] - b[1]).abs() < 1e-5, "({x}, {y}) : {a:?} au lieu de {b:?}");
+ }
+
+ let size_px = [SLOT[2] * RENDER[0], SLOT[3] * RENDER[1]];
+ assert_eq!(g.shadow_caster(RENDER), ShadowCaster::Upright { dst: SLOT, size_px, radius: mask.radius_px });
+ // Sans masque, les valeurs du backend repartent telles quelles, à l'octet.
+ let free_px = [free.s_dst[2] * RENDER[0], free.s_dst[3] * RENDER[1]];
+ assert_eq!(
+ free.mask_flat_screen(free.s_dst, free.cut, free_px, free.s_radius, RENDER),
+ (free.s_dst, free.cut, free_px, free.s_radius)
+ );
+ }
+
+ /// Incliné, angle fixe ou caméra en orbite : c'est le MÉTRAGE qui penche, avec le plan de tous
+ /// les layouts, et le slot le rogne — le conteneur, lui, ne penche jamais. Le plan est dessiné
+ /// dans le rect du slot (coins arrondis par le shader, `color.w`), et son ombre est celle de
+ /// ce qu'on voit, le plan rogné par le slot.
+ #[test]
+ fn a_tilted_zoom_tilts_the_footage_inside_its_slot() {
+ for rotation in [r#""iso""#, r#""right""#, r#""follow-cursor""#] {
+ let g = slot_plan(&slot_scene(rotation, 2.0, true), Some((0.8, 0.3)));
+ let free = slot_plan(&slot_scene(rotation, 2.0, false), Some((0.8, 0.3)));
+ let mask = g.screen_mask.expect("masque");
+ assert!(g.tilted(), "{rotation} : garde, l'écran doit pencher");
+ 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 free_px = [free.s_dst[2] * RENDER[0], free.s_dst[3] * RENDER[1]];
+ for (a, b) in quad.corners.iter().zip(free.screen_tilt(free_px).expect("incliné").corners.iter()) {
+ assert!((a.0 - b.0).abs() < 0.5 && (a.1 - b.1).abs() < 0.5, "{rotation} : {a:?} au lieu de {b:?}");
+ }
+ let (hx, hy) = quad.half_extents_px();
+ let slot_px = [SLOT[2] * RENDER[0], SLOT[3] * RENDER[1]];
+ assert!(hx > slot_px[0] * 0.5 && hy > slot_px[1] * 0.5, "{rotation} : garde, le plan zoomé déborde du slot");
+
+ let centre = g.screen_center_px(RENDER);
+ let draw = |m| tilted_screen_cb(&quad, s_px, centre, g.cut, g.focus_plane, g.s_radius, 0.0, false, RENDER, m);
+ let (cb, bare) = (draw(g.screen_mask), draw(None));
+ assert_eq!(cb.dst, SLOT, "{rotation} : dessiné dans le slot");
+ assert_eq!(cb.color[3], mask.radius_px);
+ assert_eq!(bare.color[3], 0.0, "sans masque, rien ne change");
+ // Les coins reportés dans le repère du slot : le même plan, au centième de pixel.
+ let corners = |c: &LayerCB| {
+ [[c.fx[0], c.fx[1]], [c.fx[2], c.fx[3]], [c.src_prev[0], c.src_prev[1]], [c.src_prev[2], c.src_prev[3]]]
+ .map(|[x, y]| [c.dst[0] * RENDER[0] + x, c.dst[1] * RENDER[1] + y])
+ };
+ for (a, b) in corners(&cb).iter().zip(corners(&bare).iter()) {
+ assert!((a[0] - b[0]).abs() < 1e-2 && (a[1] - b[1]).abs() < 1e-2, "{rotation} : coin {a:?} au lieu de {b:?}");
+ }
+ match g.shadow_caster(RENDER) {
+ ShadowCaster::Tilted { mask: m, .. } => assert_eq!(m, Some(mask), "{rotation}"),
+ other => panic!("{rotation} : {other:?}"),
+ }
+ }
+ // Le slot passé à l'ombre, en px locaux à sa boîte : décalé de l'origine de celle-ci.
+ let mask = ScreenMask { rect: SLOT, radius_px: 12.0 };
+ let (rect, r) = shadow_mask_fields(Some(mask), [100.0, 50.0], RENDER);
+ let want = [0.1 * 1920.0 - 100.0, 0.25 * 1080.0 - 50.0, 0.65 * 1920.0 - 100.0, 0.8 * 1080.0 - 50.0];
+ for k in 0..4 {
+ assert!((rect[k] - want[k]).abs() < 1e-3, "{rect:?} au lieu de {want:?}");
+ }
+ assert_eq!(r, 12.0);
+ assert_eq!(shadow_mask_fields(None, [100.0, 50.0], RENDER), ([0.0; 4], 0.0));
+ }
+
+ /// Le flou de confidentialité suit le métrage comme ailleurs, et le slot le rogne : ce qui en
+ /// sort n'est pas dessiné, rien à y cacher, et un masque y flouterait la caméra.
+ #[test]
+ fn a_privacy_mask_stays_inside_the_slot() {
+ let g = slot_plan(&slot_scene("null", 2.0, true), None);
+ let free = slot_plan(&slot_scene("null", 2.0, false), None);
+ let mut a = blur_annotation("");
+ // La vue x2 autour de (0.3, 0.6) : [0.05, 0.55] × [0.35, 0.85] de l'écran.
+ (a.x, a.y) = (0.2, 0.5);
+ let (m, f) = (g.privacy_mask(&a, RENDER).expect("masque"), free.privacy_mask(&a, RENDER).expect("masque"));
+ for k in 0..4 {
+ assert!((m.dst[k] - f.dst[k]).abs() < 1e-4, "dedans : {:?} au lieu de {:?}", m.dst, f.dst);
+ }
+ assert!(m.oval_ok, "dedans, l'ovale tient");
+ // À cheval sur le bord droit de la vue.
+ (a.x, a.y) = (0.45, 0.5);
+ let (m, f) = (g.privacy_mask(&a, RENDER).expect("masque"), free.privacy_mask(&a, RENDER).expect("masque"));
+ assert!(!contains(SLOT, f.dst, 1e-4), "garde : sans slot, le masque sort du slot, {:?}", f.dst);
+ assert!(contains(SLOT, m.dst, 1e-6), "{:?} sort du slot", m.dst);
+ let want = intersect_rect(f.dst, SLOT);
+ for k in 0..4 {
+ assert!((m.dst[k] - want[k]).abs() < 1e-5, "rogné, pas déplacé : {:?} au lieu de {want:?}", m.dst);
+ }
+ assert!(!m.oval_ok, "rogné, l'ovale inscrit ne couvrirait plus le secret");
+ // Hors de la vue.
+ (a.x, a.y) = (0.62, 0.18);
+ assert!(g.privacy_mask(&a, RENDER).is_none(), "hors du slot : rien à masquer");
+
+ // Incliné : dessiné dans la part du slot qu'il couvre, le warp au même endroit.
+ let t = slot_plan(&slot_scene(r#""iso""#, 2.0, true), None);
+ let tf = slot_plan(&slot_scene(r#""iso""#, 2.0, false), None);
+ (a.x, a.y) = (0.45, 0.5);
+ let (m, f) = (t.privacy_mask(&a, RENDER).expect("masque incliné"), tf.privacy_mask(&a, RENDER).expect("masque"));
+ assert!(contains(SLOT, m.dst, 1e-6), "incliné : {:?} sort du slot", m.dst);
+ let abs = |p: &PrivacyMask| p.warp.expect("incliné").map(|[x, y]| [p.dst[0] * RENDER[0] + x, p.dst[1] * RENDER[1] + y]);
+ for (x, y) in abs(&m).iter().zip(abs(&f).iter()) {
+ assert!((x[0] - y[0]).abs() < 0.5 && (x[1] - y[1]).abs() < 0.5, "incliné : coin {x:?} au lieu de {y:?}");
+ }
+ }
+
+ /// Le curseur est sur le métrage : le slot le rogne aussi.
+ #[test]
+ fn the_cursor_is_clipped_to_the_slot() {
+ let cfg = crate::config::all().pop().expect("au moins une config");
+ for (cover, want) in [(true, SLOT), (false, [-1.0, -1.0, 3.0, 3.0])] {
+ let scene = slot_scene("null", 2.0, cover);
+ let g = slot_plan(&scene, Some((0.3, 0.6)));
+ let plan = plan_cursor(
+ &g,
+ &CursorPlanInput {
+ render_px: RENDER,
+ u_max: 1.0,
+ v_max: 1080.0 / 1088.0,
+ cfg: &cfg,
+ live: live_params_from_scene(&scene),
+ scene: Some(&scene),
+ track: parked_track(0.3, 0.6),
+ t: 1.5,
+ },
+ )
+ .expect("un curseur dans la vue");
+ for k in 0..4 {
+ assert!((plan.clip[k] - want[k]).abs() < 1e-6, "slot {cover} : clip {:?} au lieu de {want:?}", plan.clip);
+ }
+ }
+ }
+
/// La parallaxe (`regions::dynamic_tilt`) passe par `plan_frame` une seule fois, et le
/// curseur la porte comme l'écran : même quad, même échelle gelée. Curseur masqué ou
/// région sans préset → rien ne bouge.
@@ -5833,6 +6200,7 @@ mod tests {
w_radius: 0.0,
shape_fade: 0.0,
window_frame: None,
+ screen_mask: None,
}
}
diff --git a/crates/compositor/src/scene.rs b/crates/compositor/src/scene.rs
index ac982f007..36dac9bb7 100644
--- a/crates/compositor/src/scene.rs
+++ b/crates/compositor/src/scene.rs
@@ -79,6 +79,9 @@ pub struct SceneLayout {
/// remplir le slot — d'autant plus visible sur un clip recadré, le crop éloignant encore le
/// ratio de la source de celui du slot.
///
+ /// Le slot MASQUE aussi l'écran : zoom et 3D y restent, rognés au lieu de déborder sur la
+ /// caméra (`frame_geometry::ScreenMask`).
+ ///
/// `#[serde(default)]` : absent → `false` → comportement "contain" historique.
#[serde(default)]
pub screen_cover: bool,
diff --git a/crates/compositor/src/shaders.hlsl b/crates/compositor/src/shaders.hlsl
index e6e5e7a5f..21a3b705c 100644
--- a/crates/compositor/src/shaders.hlsl
+++ b/crates/compositor/src/shaders.hlsl
@@ -1420,6 +1420,13 @@ float4 ps_main(VSOut i) : SV_Target
v[k] = line_cross(np, dot(quad[(k + 3) & 3], np) - r, nc, dot(quad[k], nc) - r);
}
float d = sd_convex_quad(i.local, v[0], v[1], v[2], v[3]) - r;
+ // Slot d'un layout en bloc (`dst_prev` = le slot en px locaux x0 y0 x1 y1, `mb.w` = son
+ // rayon ; nul ailleurs) : l'ombre est celle de ce qu'on voit, le plan rogné par le slot.
+ if (dst_prev.z > dst_prev.x)
+ {
+ float2 h = (dst_prev.zw - dst_prev.xy) * 0.5;
+ d = max(d, sd_round_rect(i.local - dst_prev.xy - h, h, mb.w));
+ }
float spread = max(mb.y, 1e-3);
float a = color.a * (1.0 - smoothstep(0.0, spread, d));
return float4(color.rgb * a, a);
@@ -1551,6 +1558,10 @@ float4 ps_main(VSOut i) : SV_Target
float d = (dst_prev.z > 0.5) ? sd_screen_under_bar(p, plane_px * 0.5, rad, color.z)
: sd_round_rect(p, plane_px * 0.5, rad);
float tilt_a = 1.0 - smoothstep(0.0, 1.5, d);
+ // Slot d'un layout en bloc (`color.w` = rayon de ses coins, px ; 0 ailleurs, sans effet) :
+ // `dst` EST le slot, dont le rect arrondi rogne le plan. Le conteneur masque, le métrage
+ // penche dedans (`ScreenMask`).
+ tilt_a *= quad_round_alpha(i.local, quad_px, color.w);
// Profondeur de champ : cercle de confusion en texels source, nul au focus du zoom.
// Sous un demi-texel, l'échantillon net d'avant, à l'octet : le texte net ne passe
// jamais par le RGBA de la pyramide, et `k = 0` (réglage coupé) ne quitte jamais cette
diff --git a/crates/compositor/src/shaders.metal b/crates/compositor/src/shaders.metal
index 7c3bb9576..c7102fccf 100644
--- a/crates/compositor/src/shaders.metal
+++ b/crates/compositor/src/shaders.metal
@@ -1378,6 +1378,13 @@ fragment float4 ps_main(VSOut i [[stage_in]],
v[k] = line_cross(np, dot(quad[(k + 3) & 3], np) - r, nc, dot(quad[k], nc) - r);
}
float d = sd_convex_quad(i.local, v[0], v[1], v[2], v[3]) - r;
+ // Slot d'un layout en bloc (`dst_prev` = le slot en px locaux, `mb.w` = son rayon ; nul
+ // ailleurs) : l'ombre est celle de ce qu'on voit, le plan rogné par le slot (cf. HLSL).
+ if (layer.dst_prev.z > layer.dst_prev.x)
+ {
+ float2 h = (layer.dst_prev.zw - layer.dst_prev.xy) * 0.5;
+ d = max(d, sd_round_rect(i.local - layer.dst_prev.xy - h, h, layer.mb.w));
+ }
float spread = max(layer.mb.y, 1e-3);
float a = layer.color.a * (1.0 - smoothstep(0.0, spread, d));
return float4(layer.color.rgb * a, a);
@@ -1421,6 +1428,9 @@ fragment float4 ps_main(VSOut i [[stage_in]],
float d = (layer.dst_prev.z > 0.5) ? sd_screen_under_bar(p, plane_px * 0.5, rad, layer.color.z)
: sd_round_rect(p, plane_px * 0.5, rad);
float tilt_a = 1.0 - smoothstep(0.0, 1.5, d);
+ // Slot d'un layout en bloc (`color.w` = rayon de ses coins, px ; 0 ailleurs, sans effet) :
+ // `dst` EST le slot, dont le rect arrondi rogne le plan (`ScreenMask`, cf. HLSL).
+ tilt_a *= quad_round_alpha(i.local, layer.quad_px, layer.color.w);
// Profondeur de champ : net sous un demi-texel de flou (l'échantillon d'avant, à
// l'octet), fondu au-delà vers la pyramide au niveau `log2(coc) - 1`, plafonné.
// `level(lod)` exige `mip_filter::linear` sur `samp` : sans lui, niveau 0 partout.
diff --git a/crates/compositor/src/vk_shaders/layer.wgsl b/crates/compositor/src/vk_shaders/layer.wgsl
index 8748ed27e..348b0cfc4 100644
--- a/crates/compositor/src/vk_shaders/layer.wgsl
+++ b/crates/compositor/src/vk_shaders/layer.wgsl
@@ -1354,7 +1354,10 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
let d = select(sd_round_rect(p, plane_px * 0.5, rad),
sd_screen_under_bar(p, plane_px * 0.5, rad, layer.color.z),
layer.dst_prev.z > 0.5);
- let tilt_a = 1.0 - smoothstep(0.0, 1.5, d);
+ // Slot d'un layout en bloc (`color.w` = rayon de ses coins, px ; 0 ailleurs, sans effet) :
+ // `dst` EST le slot, dont le rect arrondi rogne le plan (`ScreenMask`, cf. HLSL).
+ let tilt_a = (1.0 - smoothstep(0.0, 1.5, d))
+ * quad_round_alpha(i.local, layer.quad_px, layer.color.w);
// Profondeur de champ (cf. HLSL) : net sous un demi-texel de flou, l'echantillon
// d'avant a l'octet ; au-dela, fondu vers la pyramide demi-resolution liee en binding 4
// (a la place du masque webcam, que ce mode ne lit pas), au niveau `log2(coc) - 1`,
@@ -1394,7 +1397,13 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
let v1 = inset_corner(tl, tr, br, r);
let v2 = inset_corner(tr, br, bl, r);
let v3 = inset_corner(br, bl, tl, r);
- let d = sd_convex_quad(i.local, v0, v1, v2, v3) - r;
+ var d = sd_convex_quad(i.local, v0, v1, v2, v3) - r;
+ // Slot d'un layout en bloc (`dst_prev` = le slot en px locaux, `mb.w` = son rayon ; nul
+ // ailleurs) : l'ombre est celle de ce qu'on voit, le plan rogne par le slot (cf. HLSL).
+ if layer.dst_prev.z > layer.dst_prev.x {
+ let h = (layer.dst_prev.zw - layer.dst_prev.xy) * 0.5;
+ d = max(d, sd_round_rect(i.local - layer.dst_prev.xy - h, h, layer.mb.w));
+ }
let spread = max(layer.mb.y, 1e-3);
let a = layer.color.a * (1.0 - smoothstep(0.0, spread, d));
return vec4<f32>(layer.color.rgb * a, a);
diff --git a/src/lib/compositeLayout.test.ts b/src/lib/compositeLayout.test.ts
index 6632359d9..0d6d6ce0b 100644
--- a/src/lib/compositeLayout.test.ts
+++ b/src/lib/compositeLayout.test.ts
@@ -8,7 +8,9 @@ import {
paddingFit,
resolveWebcamReactiveZoom,
restingCompositionAspect,
+ type Size,
type StyledRenderRect,
+ type WebcamLayoutPreset,
} from "./compositeLayout";
import type { WebcamAnchor } from "./projectDefaults";
@@ -407,6 +409,25 @@ describe("computeCompositeLayout", () => {
expect(layout?.screenRect).toEqual({ x: 192, y: 108, width: 1536, height: 864 });
});
+ it("masks the screen with its box for the two block presets only", () => {
+ // `screenCover` is what the native compositor reads to crop a zoom or a 3D tilt to the
+ // screen box instead of letting it spill over the camera (`ScreenMask`).
+ const args = {
+ canvasSize: { width: 1920, height: 1080 },
+ screenSize: { width: 1920, height: 1080 },
+ webcamSize: { width: 960, height: 720 },
+ };
+ const cover = (layoutPreset: WebcamLayoutPreset, webcamSize: Size | null = args.webcamSize) =>
+ computeCompositeLayout({ ...args, webcamSize, layoutPreset })?.screenCover ?? false;
+
+ expect(cover("dual-frame")).toBe(true);
+ expect(cover("vertical-stack")).toBe(true);
+ expect(cover("picture-in-picture")).toBe(false);
+ expect(cover("no-webcam")).toBe(false);
+ // Without a camera the block falls back to the screen alone, which zooms like any other.
+ expect(cover("dual-frame", null)).toBe(false);
+ });
+
it("forces circular and square masks to use square dimensions", () => {
const circularLayout = computeCompositeLayout({
canvasSize: { width: 1920, height: 1080 },
diff --git a/src/lib/compositeLayout.ts b/src/lib/compositeLayout.ts
index 4319790ba..4c5099cfd 100644
--- a/src/lib/compositeLayout.ts
+++ b/src/lib/compositeLayout.ts
@@ -175,7 +175,10 @@ export interface WebcamCompositeLayout {
screenRect: RenderRect;
webcamRect: StyledRenderRect | null;
screenBorderRadius?: number;
- /** When true, the video should be scaled to cover screenRect (cropping overflow). */
+ /**
+ * When true, the video should be scaled to cover screenRect (cropping overflow), and
+ * screenRect masks it: a zoom or a 3D tilt stays inside instead of growing past it.
+ */
screenCover?: boolean;
}
diff --git a/src/native/sceneDescription.ts b/src/native/sceneDescription.ts
index 83f78fb7a..27a7ba7bb 100644
--- a/src/native/sceneDescription.ts
+++ b/src/native/sceneDescription.ts
@@ -295,6 +295,9 @@ export interface SceneLayout {
* honours on the web path; shipping it here is what lets the native compositor agree.
* Without it native stretched the source to fill the slot — most visible on a cropped
* clip, the crop pushing the source aspect further from the slot's.
+ *
+ * The slot also MASKS the screen: a zoom or a 3D tilt stays inside it, cropped, instead of
+ * spilling over the camera (`ScreenMask` in `frame_geometry.rs`).
*/
screenCover?: boolean;
/**
diff --git a/technical-documentation/testing/manual-e2e-checklist.md b/technical-documentation/testing/manual-e2e-checklist.md
index 14e60a9ad..d51469366 100644
--- a/technical-documentation/testing/manual-e2e-checklist.md
+++ b/technical-documentation/testing/manual-e2e-checklist.md
@@ -636,3 +636,4 @@ The mask comes from the native compositor (ONNX Runtime + the vendored selfie-se
| 2026-09-24 | installed `v1.13.0-rc.6` — CI-built DMG `Openscreen-macOS-Apple-Silicon-1.13.0-rc.6.dmg` from the GitHub Release (tag `6eb86b17`, build run 35990025043), Developer ID signed + notarized (`spctl`: Notarized Developer ID); native payload one uniformly stamped set (34 files, 2026-09-24 13:10). rc.6 = rc.5 (#733 backport) + cherry-picks of #748, #749, #750 (2 commits), #719 (2 commits), #666 | macOS 26.5 (25F71), M1 Mac mini, one 3840×2160 display; no camera, no microphone | Pass — risk-scoped slice, no defect | **Scoped to what rc.5→rc.6 changed, not a full-file run** (the full pass is the rc.4 row). Real OS mouse/keyboard; every level, duration and frame claim measured on exported files. **#733 HUD dialogs:** HUD device-settings → Check for Updates shows "up to date (1.13.0-rc.6)" with **no grey rectangle** over the desktop (rc.4: ~900×700 greyed). **#743 file panels (widest blast radius — every save/open dialog):** Export MP4 → *Save Exported Video* is now a sheet on the editor; three clicks on the editor behind the modal leave it attached and visible (rc.4: panel fell behind, modal stuck on "Starting…"); Cancel returns the modal to its options. Open Project → *Browse files…* and the audio-import picker (`m`) also open as sheets on the editor and complete. **#744 GIF timing:** GUI GIF export 15 fps / Medium: 517 frames, delays 7/6 cs alternating (345×7 + 172×6), playback **34.47 s = frames/15 exactly**, against 34.40 s for the MP4 of the same project (rc.4: 30.48 s for a 33.87 s programme); CLI GIF 15 fps: 543 frames, 36.20 s = 543/15. **#747:** Keyboard Shortcuts → Fixed shows Undo "⌘ + Z" and Redo "⌘ + ⇧ + Z / ⌘ + Y". **#719 CLI export of v2 projects:** three hand-written v2 projects over a real take — with `cropRegion {0.25,0.25,0.5,0.5}` the CLI export on **rc.4 ignored the crop (full frame)**, on rc.6 it renders the centre crop; `cursorSize: 6` renders a cursor twice the default (3.0) size, compared frame-for-frame against the same project without the key; an out-of-range crop `{-0.2,0.5,0.6,0.8}` exports without error (clamped); the v2 crop project also opens in the GUI with the crop applied. **#666 imported-audio gain:** the Output level slider now goes well below −12 dB (set −37.5 and −39.0 dB); exported level of the 1 kHz bed by single-bin lock-in over 11–13 s: **−31.1 dBFS at −4 dB (rc.4) → −65.9 dBFS at −39 dB (rc.6), Δ 34.8 dB for 35 dB requested**, muted floor −96.2 dBFS. **Smoke:** record from the editor's Rec stage (tray icon red, stop from tray *Stop Recording*) → editor opens on the 13.23 s 3840×2160 H.264 + AAC take with an auto zoom → add a trim (0.68 s) → Export MP4 1080p30: 12.60 s (13.23 − 0.68 = 12.55 expected, within 2 frames). Main-process log: no error lines. **Not covered:** everything outside this slice (see the rc.4 row); #743 on Windows/Linux (the helper keeps owning the HUD there — unit-tested only); the native-bridge project save path was exercised only through Open; webcam/mic still untestable on this machine. Open, not in rc.6: #742 (animated annotation during playback, preview only), #745 (not reproduced), #729 (Whisper hallucination on trailing silence). |
| 2026-09-24 | `claude/zoom-speed-adjustment-fb8abd`, the zoom-pace PR for #683, on `d951e532`; `compositor_view.node` rebuilt from its first commit `cc88c423` (the later motion-blur fix at speed boundaries does not touch these measurements, taken with motion blur off) by `npm run build:native:compositor` (2026-09-24 22:17), ffmpeg DLLs hash-identical to the vendored SDK; renderer rebuilt with `npm run build-vite` | Windows 11 26200 | Partial — no defect | **Zoom pace and speed regions, through the app's real export (`electron . export <project> -o <mp4>`).** Source: synthetic 1920×1080 clip, a 160 px white square centred. Two legacy projects: `plain` at 1× with a 1.25× zoom on [2 s, 3 s] and a 5× zoom on [6 s, 8 s]; `sped` with the whole clip at 4× and the same zooms at 4× the source times. Zoom scale measured on every frame of the 60 fps exports (area-weighted width of the square). New addon: `plain` and `sped` match frame for frame within a maximum scale difference of 0.0001; 1.25× moves 2→98 % in 0.53 s, peak 0.9 e-folds/s; 5× in 1.12 s, peak 2.8 e-folds/s; each zoom reaches 98 % before its region starts and leaves when it ends. Same app build pointed at the 2026-09-13 addon (`OPENSCREEN_COMPOSITOR_VIEW_NODE`): 5× peaks at 13 e-folds/s at 1× and 31 at 4×, where the whole zoom-in takes 0.18 s. **Not covered:** the GUI editor preview (same `plan_frame` as the export, not driven), Full Camera under a speed region and chained zooms (unit-tested only), macOS and Linux rendering. |
| 2026-09-25 | `claude/ratio-auto-screen-studio-df6b2e` (Auto format), tree of `ace7af33` + `972f8cf3` before the default flip; the test projects state `auto` explicitly, so the flip does not change them. `compositor_view.node` not rebuilt (no Rust change in the PR): the 2026-09-24 22:17 build from `zoom-speed-adjustment-fb8abd`, its whole `bin/win32-x64` directory copied aside and loaded through `OPENSCREEN_COMPOSITOR_VIEW_NODE`; renderer rebuilt with `npm run build-vite` | Windows 11 26200, NVENC export | Partial — no defect | **Auto format, preview geometry and real export.** Preview: the renderer in browser mode (`vite-dev`, `?windowType=editor`), 4:3 fixture `tests/fixtures/sample.webm` with `website/static/video/webcam.mp4` as camera, padding 50, geometry read from the DOM. Fixed 16:9 + top / bottom left 265 px empty per side against 42 px on top; Auto gave a portrait 259×418 frame, square 207×207 camera, 26 px on all four sides. Side by side, padding 0 → 100: frame 2.36 → 1.82, border 0 → 84 px, camera square throughout. Fixed 16:9 side by side gave a 4:5 camera and the block at 80 % of the width, which is the old formula's answer (computed, not re-measured on the old build). Export: `electron . export <project> -o <mp4> --quality source`, synthetic 1280×720 blue screen and 640×480 green camera, wallpaper `#303030`, padding 50, roundness and shadow 0, frame at 1.5 s parsed as PPM. Top / bottom 858×1258, camera 687×686, margins 86/86/85/86; side by side 1240×506, camera 405×406, margins 50 on all sides; PiP 1194×736, screen margins 74/74/74/76. **Not run:** the real Electron editor window (preview checked in browser mode only), the native live preview, the default flip on a fresh recording (unit tests only), a non-English Format menu, macOS and Linux. |
+| 2026-09-25 | worktree `zoom-overflow-layouts-698eb0`, `claude/zoom-overflow-layouts-698eb0` on `ff3c3f51` + the slot-mask change; `compositor_view.node` rebuilt from this tree (`cargo build -p compositor-view-napi --release`), baseline addon built the same way from `ff3c3f51`; ffmpeg DLLs hash-identical to the vendored SDK; renderer rebuilt with `npm run build-vite` | Windows 11 26200, NVENC export | Partial — no defect | **The block layouts' screen slot masks the zoom and the 3D (overflow hidden), through the app's real export (`electron . export <project> -o <mp4>`).** Source: synthetic 1920×1080 `testsrc2` screen and 1280×720 bars webcam, 4 s. Legacy 16:9 projects, padding 50 %, a depth-4 (2.2×) zoom at focus (0.3, 0.6) on [0.5 s, 3.5 s], frame at 2 s. `dual-frame`: the baseline addon spills the zoomed screen under the camera and off the frame; the new one crops it to its rounded slot, camera and gap untouched. `dual-frame` + `iso`: the footage tilts as in any layout and the slot, which stays upright, crops it; where the tilted footage leaves the slot, the wallpaper shows and the shadow follows the visible part. `picture-in-picture`: the whole export is bit-identical between the two addons (PSNR inf on all 240 frames). D3D11 frames through `live::Player`, the preview engine, also checked `vertical-stack`, the `right` preset and the `follow-cursor` camera. **Not covered:** the GUI editor preview (same `plan_frame`, not driven), a window or device frame in a block layout (left unmasked), privacy blur and click impacts in a slot (unit-tested only), macOS and Linux rendering (WGSL validated with naga, Metal not compiled). |