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): 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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<CursorPSome(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.rsindex 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.hlslindex 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_Targetv[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_Targetfloat 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 cettediff --git a/crates/compositor/src/shaders.metal b/crates/compositor/src/shaders.metalindex 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.wgslindex 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.tsindex 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.tsindex 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.tsindex 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.mdindex 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). |