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): motion-blur the framed screen as one object under a 3D camera
EtienneLescotd6b46edd4bf5
diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rsindex fd900f0e8..e6a655dbd 100644--- a/crates/compositor/src/compositor_linux.rs+++ b/crates/compositor/src/compositor_linux.rs@@ -2093,7 +2093,9 @@ impl Compositor {// Au mode 8, ces deux champs portent deja les coins projetes du quad// (BR/BL dans `src_prev`, `plane_px` dans `dst_prev`) : le plan d'avant// arrive dans ses propres champs (`trail_a`/`trail_b`/`trail_mb`,- // `FrameGeometry::tilt_trail`), meme flou borne a une frame.+ // `FrameGeometry::tilt_pixel_trail`), meme flou borne a une frame.+ // Dans les deux modes, ce flou par pixel s'efface quand l'ecran CADRE est+ // floute en bloc (mode 18, `trail` plus bas).// Sous un cadre de fenetre, l'ecran garde ses coins HAUTS carres (`mb.w` au mode 0,// `dst_prev.z` au mode 8) ; 0 sans cadre, soit le rendu d'avant.let square_top = g.screen_square_top();@@ -2114,7 +2116,7 @@ impl Compositor {color: [1.0, 1.0, 1.0, 1.0],src_prev: g.cut,dst_prev: g.s_dst_prev,- mb: [g.screen_pixel_taps(), g.mb_amount, top_lift, square_top],+ mb: [g.screen_pixel_taps([rw, rh]), g.mb_amount, top_lift, square_top],..Default::default()}}@@ -2130,7 +2132,7 @@ impl Compositor {dof,[rw, rh],g.screen_mask,- g.tilt_trail([rw, rh]),+ g.tilt_pixel_trail([rw, rh]),),};// Bind group construit AVANT le pass (doit vivre pendant tout le pass) ;@@ -2201,8 +2203,9 @@ impl Compositor {let device_frame = g.device_frame_cb([rw, rh]).map(|cb| self.make_bind(&cb, None, &dummy));// Flou de mouvement de l'ecran CADRE (`FrameGeometry::screen_trail`) : l'ombre, le cadre,// le metrage et l'appareil ci-dessus passent dans un rendu isole (`trail_view`), que le- // mode 18 recompose sur le fond ; binding 4 = ce rendu, les plans = le metrage.- let trail = (tilt.is_none() && g.screen_trail()).then(|| {+ // mode 18 recompose sur le fond, droit ou incline ; binding 4 = ce rendu, les plans = le+ // metrage.+ let trail = g.screen_trail([rw, rh]).then(|| {self.make_bind_b4(&g.screen_trail_cb([rw, rh]),Some((&sy, &su, &sv)),@@ -4849,9 +4852,9 @@ mod tests {}}- /// Ecran sous chrome de fenetre clair, zoome x1,3 de 1 s a 6 s, a l'instant `t` de la- /// timeline, avec le flou de mouvement `blur` (0..1).- fn compose_zooming_window(comp: &Compositor, gpu: &Gpu, t: f32, blur: f32) -> Vec<u8> {+ /// Ecran sous chrome de fenetre clair, zoome x1,3 de 1 s a 6 s sous `rotation` (JSON), a+ /// l'instant `t` de la timeline, avec le flou de mouvement `blur` (0..1).+ fn compose_zooming_window(comp: &Compositor, gpu: &Gpu, rotation: &str, t: f32, blur: f32) -> Vec<u8> {let json = format!(r##"{{"clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rounded",@@ -4859,7 +4862,7 @@ mod tests {"screenRect":{{"x":0.1,"y":0.1,"width":0.8,"height":0.8}}}},"effects":{{"padding":0.3,"blur":false,"shadow":0.6,"roundnessFrac":0.03,"motionBlur":{blur},"frame":"window-light"}},"background":{{"kind":"color","color":"#6070a0"}},- "zoomRegions":[{{"clipIndex":0,"startSec":1,"endSec":6,"scale":1.3,"focusX":0.5,"focusY":0.5}}],+ "zoomRegions":[{{"clipIndex":0,"startSec":1,"endSec":6,"scale":1.3,"focusX":0.5,"focusY":0.5,"rotation":{rotation}}}],"annotations":[],"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},@@ -4886,9 +4889,10 @@ mod tests {}}- /// Le flou de mouvement prend l'ecran CADRE en bloc : pendant la rampe du zoom, la barre de- /// titre claire file avec le metrage au lieu de rester nette (elle perd des pixels francs,- /// etales sur le fond et l'ecran). Immobile, le rendu flou est celui du rendu net, a l'octet.+ /// Le flou de mouvement prend l'ecran CADRE en bloc, droit comme incline : pendant la rampe+ /// du zoom, la barre de titre claire file avec le metrage au lieu de rester nette (elle perd+ /// des pixels francs, etales sur le fond et l'ecran). Immobile, au palier du zoom comme+ /// apres lui, le rendu flou est celui du rendu net, a l'octet.#[test]fn the_window_frame_trails_with_the_screen_under_motion_blur() {let Some(gpu) = gpu() else { return };@@ -4896,40 +4900,43 @@ mod tests {let bright = |rgba: &[u8]| {rgba.chunks_exact(4).filter(|p| p[0] > 215 && p[1] > 215 && p[2] > 215).count()};- let still = 9.0;- assert!(- compose_zooming_window(&comp, &gpu, still, 0.0)- == compose_zooming_window(&comp, &gpu, still, 1.0),- "immobile, le flou ne doit rien changer"- );let out_dir = std::env::var("OPENSCREEN_FRAME_OUT").ok();- let mut best = (0.0f32, 0.0f32);- // La rampe de sortie du zoom, ~6,0 s -> 6,8 s.- for k in 0..=9 {- let t = 5.9 + k as f32 * 0.1;- let sharp = compose_zooming_window(&comp, &gpu, t, 0.0);- let blurred = compose_zooming_window(&comp, &gpu, t, 1.0);- // Encore zoome, la barre est hors champ : rien a mesurer a cet instant.- if bright(&sharp) < 1000 {- continue;+ for (label, rotation) in [("flat", "null"), ("iso", r#""iso""#)] {+ for still in [3.5, 9.0] {+ assert!(+ compose_zooming_window(&comp, &gpu, rotation, still, 0.0)+ == compose_zooming_window(&comp, &gpu, rotation, still, 1.0),+ "{label} a t={still} : immobile, le flou ne doit rien changer"+ );}- let drop = 1.0 - bright(&blurred) as f32 / bright(&sharp) as f32;- if drop > best.0 {- best = (drop, t);- if let Some(dir) = &out_dir {- for (name, rgba) in [("sharp", sharp), ("blurred", blurred)] {- let path = format!("{dir}/linux-trail-{name}.png");- image::RgbaImage::from_raw(1280, 720, rgba)- .expect("dimensions du readback")- .save(&path)- .unwrap_or_else(|e| panic!("ecriture {path} : {e}"));+ let mut best = (0.0f32, 0.0f32);+ // La rampe de sortie du zoom, ~6,0 s -> 6,8 s.+ for k in 0..=9 {+ let t = 5.9 + k as f32 * 0.1;+ let sharp = compose_zooming_window(&comp, &gpu, rotation, t, 0.0);+ let blurred = compose_zooming_window(&comp, &gpu, rotation, t, 1.0);+ // Encore zoome, la barre est hors champ : rien a mesurer a cet instant.+ if bright(&sharp) < 1000 {+ continue;+ }+ let drop = 1.0 - bright(&blurred) as f32 / bright(&sharp) as f32;+ if drop > best.0 {+ best = (drop, t);+ if let Some(dir) = &out_dir {+ for (name, rgba) in [("sharp", sharp), ("blurred", blurred)] {+ let path = format!("{dir}/linux-trail-{label}-{name}.png");+ image::RgbaImage::from_raw(1280, 720, rgba)+ .expect("dimensions du readback")+ .save(&path)+ .unwrap_or_else(|e| panic!("ecriture {path} : {e}"));+ }}}}+ eprintln!("{label} : barre de titre -{:.1} % de pixels francs a t={}", best.0 * 100.0, best.1);+ let best = best.0;+ assert!(best > 0.05, "{label} : la barre de titre reste nette pendant le zoom (au mieux {best:.3})");}- eprintln!("barre de titre : -{:.1} % de pixels francs a t={}", best.0 * 100.0, best.1);- let best = best.0;- assert!(best > 0.05, "la barre de titre reste nette pendant le zoom (au mieux {best:.3})");}/// Un degrade de fond est opaque et montre chacun de ses stops, meme quand le premier est adiff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rsindex 21abc2113..e7bde5a05 100644--- a/crates/compositor/src/compositor_macos.rs+++ b/crates/compositor/src/compositor_macos.rs@@ -1280,7 +1280,7 @@ impl Compositor {top_lift: f32,// Le slot d'un layout en bloc, qui rogne le plan (`FrameGeometry::screen_mask`).mask: Option<crate::frame_geometry::ScreenMask>,- // Le plan à la frame d'avant, pour son flou de mouvement (`FrameGeometry::tilt_trail`).+ // Le plan à la frame d'avant, pour son flou de mouvement (`FrameGeometry::tilt_pixel_trail`).trail: Option<crate::frame_geometry::TiltTrail>,y: &metal::Texture,uv: &metal::Texture,@@ -2189,8 +2189,8 @@ impl Compositor {let tilt = g.screen_tilt(s_px);// Flou de mouvement de l'écran CADRÉ (`FrameGeometry::screen_trail`) : ombre, cadre,// métrage et appareil se dessinent dans un rendu isolé et transparent, que le mode 18- // recompose ensuite sur le fond le long de la trajectoire de la boîte.- let trail = tilt.is_none() && g.screen_trail();+ // recompose ensuite sur le fond le long de la trajectoire de la boîte, ou du plan incliné.+ let trail = g.screen_trail([rw, rh]);let mut enc = if trail {self.begin_pass(cmd_buf,@@ -2251,7 +2251,7 @@ impl Compositor {color: [0.0, 0.0, 0.0, 1.0],src_prev: [su0, sv0, su1, sv1],dst_prev: g.s_dst_prev,- mb: [g.screen_pixel_taps(), g.mb_amount, top_lift, square_top],+ mb: [g.screen_pixel_taps([rw, rh]), g.mb_amount, top_lift, square_top],..Default::default()},&sy,@@ -2267,7 +2267,7 @@ impl Compositor {g.s_radius,top_lift,g.screen_mask,- g.tilt_trail([rw, rh]),+ g.tilt_pixel_trail([rw, rh]),&sy,&suv,dof_pyramid.as_ref(),diff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rsindex f6bf3bdd6..69567a620 100644--- a/crates/compositor/src/compositor_windows.rs+++ b/crates/compositor/src/compositor_windows.rs@@ -1874,8 +1874,8 @@ impl Compositor {let render_px = [self.rw(), self.rh()];// Flou de mouvement de l'écran CADRÉ (`FrameGeometry::screen_trail`) : ombre, cadre,// métrage et appareil se dessinent dans un rendu isolé et transparent, que le mode 18- // recompose ensuite sur le fond le long de la trajectoire de la boîte.- let trail = tilt.is_none() && g.screen_trail();+ // recompose ensuite sur le fond le long de la trajectoire de la boîte, ou du plan incliné.+ let trail = g.screen_trail(render_px);if trail {self.ctx.OMSetRenderTargets(Some(&[Some(self.trail_rtv.clone())]), None);self.ctx.ClearRenderTargetView(&self.trail_rtv, &[0.0, 0.0, 0.0, 0.0]);@@ -1929,7 +1929,7 @@ impl Compositor {dof,render_px,g.screen_mask,- g.tilt_trail(render_px),+ g.tilt_pixel_trail(render_px),),&sy,&suv,@@ -1954,7 +1954,7 @@ impl Compositor {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],dst_prev: s_dst_prev,- mb: [g.screen_pixel_taps(), mb_amount, top_lift, square_top],+ mb: [g.screen_pixel_taps(render_px), mb_amount, top_lift, square_top],..Default::default()},&sy,diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rsindex dd38c8705..15101b20a 100644--- a/crates/compositor/src/frame_geometry.rs+++ b/crates/compositor/src/frame_geometry.rs@@ -58,6 +58,7 @@ pub struct LayerCB {/// Mode 8 : le plan à la frame PRÉCÉDENTE, coins TL, TR (`trail_a`) puis BR, BL (`trail_b`)/// en px locaux comme `fx`/`src_prev`, et `trail_mb` = `[taps, force, 0, 0]` de son flou de/// mouvement, ceux du mode 0 (`mb.xy`). `trail_mb` nul ailleurs : aucun tap, rien n'est lu.+ /// Mode 18 incliné : les mêmes coins d'avant, en fractions de la sortie (`screen_trail_cb`).pub trail_a: [f32; 4],pub trail_b: [f32; 4],pub trail_mb: [f32; 4],@@ -1203,9 +1204,10 @@ pub struct TiltTrail {/// 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.///-/// `trail` : le plan à la frame précédente. Le shader floute le contenu le long du chemin qu'a-/// parcouru chaque pixel depuis, borné à une frame et réglé comme le mode 0 (`trail_a`, `trail_b`,-/// `trail_mb`). `None`, ou un seul tap : l'échantillon net, le rendu d'avant à l'octet.+/// `trail` : le plan à la frame précédente (`FrameGeometry::tilt_pixel_trail`). Le shader floute+/// le contenu le long du chemin qu'a parcouru chaque pixel depuis, borné à une frame et réglé comme+/// le mode 0 (`trail_a`, `trail_b`, `trail_mb`). `None`, ou un seul tap : l'échantillon net, le+/// rendu d'avant à l'octet.#[allow(clippy::too_many_arguments)]pub fn tilted_screen_cb(quad: &crate::regions::TiltedQuad,@@ -1922,8 +1924,9 @@ impl FrameGeometry {})}- /// Le plan incliné une frame d'écran plus tôt, avec le réglage du flou : ce que le mode 8- /// floute (`tilted_screen_cb`). `None` quand l'écran est droit ou le flou coupé.+ /// Le plan incliné une frame d'écran plus tôt, avec le réglage du flou : d'où part la+ /// traînée de l'écran cadré (`screen_trail_cb`), ou celle du seul métrage sous un masque de+ /// bloc (`tilt_pixel_trail`). `None` quand l'écran est droit ou le flou coupé.////// La frame d'avant est celle du mode 0 : la boîte au zoom d'avant (`s_dst_prev`), et ici la/// rotation de base d'avant (un angle fixe entre avec le zoom) ou la caméra réelle d'avant@@ -1999,36 +2002,57 @@ impl FrameGeometry {}}- /// L'écran droit se déplace-t-il EN BLOC sous le flou de mouvement sur cette frame ?+ /// L'écran cadré se déplace-t-il EN BLOC sous le flou de mouvement sur cette frame ?////// La coupe est la même aux deux frames : tout le mouvement de l'écran vient de sa boîte,- /// `s_dst_prev` → `s_dst`, et l'ombre, le cadre et l'appareil sont taillés dans cette même- /// boîte. C'est donc un objet rigide, et on le floute comme tel (mode 18, `screen_trail_cb`) :- /// flouter le seul métrage laissait un contenu qui file dans un cadre aux bords nets.+ /// `s_dst_prev` → `s_dst`, et incliné, du plan qui la montre (`tilt_trail`). L'ombre, le cadre+ /// et l'appareil sont taillés dans cette boîte et posés sur ce plan. C'est donc un objet+ /// rigide, et on le floute comme tel (mode 18, `screen_trail_cb`) : flouter le seul métrage+ /// laissait un contenu qui file dans un cadre aux bords nets, et sous une caméra 3D, c'était+ /// le cas de tout zoom.+ ///+ /// Incliné, le plan a bougé quand ses coins ont bougé : sans mouvement, ceux de `tilt_trail`+ /// sont les siens au bit près, et le rendu reste celui d'avant, à l'octet.////// Pas sous un masque de bloc : la case ne bouge pas, seul le métrage bouge dedans, et le- /// flou par pixel du mode 0 reste le bon. Le chemin incliné n'a pas de flou (l'appelant ne- /// demande que sur écran droit).- pub fn screen_trail(&self) -> bool {- self.mb_taps >= 2.0- && self.mb_amount > 0.001- && self.s_dst != self.s_dst_prev- && self.screen_mask.is_none()+ /// flou par pixel (modes 0 et 8) reste le bon.+ pub fn screen_trail(&self, render_px: [f32; 2]) -> bool {+ if self.mb_taps < 2.0 || self.mb_amount <= 0.001 || self.screen_mask.is_some() {+ return false;+ }+ match self.screen_tilt_in(render_px) {+ None => self.s_dst != self.s_dst_prev,+ Some(quad) => self.tilt_trail(render_px).is_some_and(|t| t.corners != quad.corners),+ }}/// Taps du flou PAR PIXEL du mode 0 de l'écran : un seul quand `screen_trail` floute déjà/// l'objet entier, sinon le métrage serait flouté deux fois.- pub fn screen_pixel_taps(&self) -> f32 {- if self.screen_trail() { 1.0 } else { self.mb_taps }+ pub fn screen_pixel_taps(&self, render_px: [f32; 2]) -> f32 {+ if self.screen_trail(render_px) { 1.0 } else { self.mb_taps }+ }++ /// La traînée PAR PIXEL du mode 8 : `tilt_trail`, sauf quand `screen_trail` floute déjà+ /// l'objet entier. Le masque de confidentialité, lui, lit toujours `tilt_trail` : les deux+ /// flous étalent le secret sur le même chemin.+ pub fn tilt_pixel_trail(&self, render_px: [f32; 2]) -> Option<TiltTrail> {+ self.tilt_trail(render_px).filter(|_| !self.screen_trail(render_px))}/// Le calque du mode 18 : le rendu isolé de l'écran cadré (t2), recomposé le long de sa- /// trajectoire. `fx` = la boîte courante, `dst_prev` = la précédente, `src` = la coupe (le- /// métrage relu directement là où le rendu isolé s'arrête au bord de la sortie), `quad_px` et- /// `radius_px` = la boîte courante en px et ses coins : ce repli ne lit le métrage que dans- /// l'ouverture arrondie, jamais sous la lunette d'un appareil.+ /// trajectoire. `src` = la coupe (le métrage relu directement là où le rendu isolé s'arrête+ /// au bord de la sortie), `quad_px` et `radius_px` = l'écran et ses coins : ce repli ne lit le+ /// métrage que dans l'ouverture arrondie, jamais sous la lunette d'un appareil.+ ///+ /// À plat, la trajectoire est celle de la boîte : `fx` = la courante, `dst_prev` = la+ /// précédente. Incliné (`mb.z` = 1), celle du plan : ses coins TL, TR, BR, BL courants dans+ /// `fx`/`src_prev` et ceux de `tilt_trail` dans `trail_a`/`trail_b`, en fractions de la+ /// sortie comme la boîte ; `quad_px` et `radius_px` sont alors pris dans le plan, comme au+ /// mode 8. `mb.w` = le warp du plan (`TiltedQuad::warp_flag`, bilinéaire sous un angle fixe,+ /// projectif sous la caméra réelle ou un appareil) : le shader passe par lui dans les deux+ /// sens, comme le mode 8 qui a dessiné le métrage.pub fn screen_trail_cb(&self, render_px: [f32; 2]) -> LayerCB {- LayerCB {+ let flat = LayerCB {dst: [0.0, 0.0, 1.0, 1.0],src: self.cut,quad_px: [self.s_dst[2] * render_px[0], self.s_dst[3] * render_px[1]],@@ -2039,6 +2063,24 @@ impl FrameGeometry {dst_prev: self.s_dst_prev,mb: [self.mb_taps, self.mb_amount, 0.0, 0.0],..Default::default()+ };+ let (Some(quad), Some(trail)) = (self.screen_tilt_in(render_px), self.tilt_trail(render_px))+ else {+ return flat;+ };+ let c = self.screen_center_px(render_px);+ let out = |(x, y): (f32, f32)| [(c[0] + x) / render_px[0], (c[1] + y) / render_px[1]];+ let [tl, tr, br, bl] = quad.corners.map(out);+ let [ptl, ptr, pbr, pbl] = trail.corners.map(out);+ LayerCB {+ quad_px: flat.quad_px.map(|v| v * quad.scale),+ radius_px: self.s_radius * quad.scale,+ fx: [tl[0], tl[1], tr[0], tr[1]],+ src_prev: [br[0], br[1], bl[0], bl[1]],+ trail_a: [ptl[0], ptl[1], ptr[0], ptr[1]],+ trail_b: [pbr[0], pbr[1], pbl[0], pbl[1]],+ mb: [self.mb_taps, self.mb_amount, 1.0, quad.warp_flag()],+ ..flat}}@@ -4409,19 +4451,76 @@ mod tests {let mut g = framed_plan(&framed_scene(frame, "null", 1.5, false));(g.mb_taps, g.mb_amount) = (16.0, 1.0);g.s_dst_prev = g.s_dst;- assert!(!g.screen_trail(), "{frame}: boîte immobile");- assert_eq!(g.screen_pixel_taps(), 16.0);+ assert!(!g.screen_trail(RENDER), "{frame}: boîte immobile");+ assert_eq!(g.screen_pixel_taps(RENDER), 16.0);g.s_dst_prev[2] *= 0.9;- assert!(g.screen_trail(), "{frame}: boîte qui bouge");- assert_eq!(g.screen_pixel_taps(), 1.0, "{frame}: flou compté deux fois");+ assert!(g.screen_trail(RENDER), "{frame}: boîte qui bouge");+ assert_eq!(g.screen_pixel_taps(RENDER), 1.0, "{frame}: flou compté deux fois");let cb = g.screen_trail_cb(RENDER);assert_eq!((cb.fx, cb.dst_prev, cb.src), (g.s_dst, g.s_dst_prev, g.cut));+ assert_eq!(cb.mb, [16.0, 1.0, 0.0, 0.0], "{frame}: la boîte, pas le plan");g.mb_amount = 0.0;- assert!(!g.screen_trail(), "{frame}: flou coupé");+ assert!(!g.screen_trail(RENDER), "{frame}: flou coupé");g.mb_amount = 1.0;g.screen_mask = Some(ScreenMask { rect: [0.0, 0.0, 0.5, 1.0], radius_px: 0.0 });- assert!(!g.screen_trail(), "{frame}: la case d'un bloc ne bouge pas");- assert_eq!(g.screen_pixel_taps(), 16.0);+ assert!(!g.screen_trail(RENDER), "{frame}: la case d'un bloc ne bouge pas");+ assert_eq!(g.screen_pixel_taps(RENDER), 16.0);+ }+ }++ /// Sous une caméra 3D aussi (angle fixe ou caméra réelle), l'écran cadré est flouté en bloc :+ /// pendant la rampe du zoom, son PLAN bouge, et le mode 8 lâche alors sa traînée par pixel,+ /// sinon le métrage serait flouté deux fois. Le calque porte les coins du plan en fractions de+ /// la sortie : ceux que le mode 8 dessine, et ceux de `tilt_trail`. Au palier, rien ne bouge.+ #[test]+ fn a_moving_tilted_screen_is_motion_blurred_as_one_object() {+ let cfg = crate::config::all().pop().expect("au moins une config");+ for rotation in [r#""iso""#, r#""follow-cursor""#] {+ for frame in ["", r#","frame":"laptop""#] {+ let mut scene = framed_scene(frame, rotation, 1.5, false);+ scene.effects.motion_blur = 1.0;+ // La région démarre à 2 s : à 1,6 s, sa rampe d'entrée est en cours.+ scene.zoom_regions[0].start_sec = 2.0;+ let at = |t: f32| {+ let input = golden_input(&scene, &cfg);+ plan_frame(&FrameGeometryInput { render_px: RENDER, timeline_t_override: Some(t), ..input })+ };+ let case = format!("{rotation}{frame}");++ let hold = at(3.0);+ assert!(hold.tilted(), "{case}: le palier doit être incliné");+ assert!(!hold.screen_trail(RENDER), "{case}: au palier, rien ne bouge");+ assert!(hold.tilt_pixel_trail(RENDER).is_some(), "{case}: le mode 8 garde sa traînée");++ let g = at(1.6);+ let quad = g.screen_tilt_in(RENDER).expect("incliné");+ let trail = g.tilt_trail(RENDER).expect("traînée");+ assert_ne!(trail.corners, quad.corners, "{case}: le plan doit bouger à 1,6 s");+ assert!(g.screen_trail(RENDER), "{case}: le plan bouge, le cadre doit suivre");+ assert_eq!(g.tilt_pixel_trail(RENDER), None, "{case}: flou compté deux fois");++ let cb = g.screen_trail_cb(RENDER);+ // Le warp du plan, celui du mode 8 : bilinéaire sous un angle fixe nu, projectif+ // sous la caméra réelle ou un appareil.+ let warp = if rotation == r#""iso""# && frame.is_empty() { 0.0 } else { 1.0 };+ assert_eq!(quad.warp_flag(), warp, "{case}: warp du plan");+ assert_eq!((cb.mode, cb.mb, cb.src), (18.0, [g.mb_taps, g.mb_amount, 1.0, warp], g.cut));+ let c = g.screen_center_px(RENDER);+ let out = |(x, y): (f32, f32)| [(c[0] + x) / RENDER[0], (c[1] + y) / RENDER[1]];+ let pairs = |a: [f32; 4], b: [f32; 4]| [[a[0], a[1]], [a[2], a[3]], [b[0], b[1]], [b[2], b[3]]];+ assert_eq!(pairs(cb.fx, cb.src_prev), quad.corners.map(out), "{case}: coins courants");+ assert_eq!(pairs(cb.trail_a, cb.trail_b), trail.corners.map(out), "{case}: coins d'avant");+ // L'ouverture du repli se mesure dans le plan, comme au mode 8.+ let s_px = [g.s_dst[2] * RENDER[0], g.s_dst[3] * RENDER[1]];+ assert_eq!(cb.quad_px, s_px.map(|v| v * quad.scale));+ assert_eq!(cb.radius_px, g.s_radius * quad.scale);++ // Sous un masque de bloc, la case ne bouge pas : retour au flou par pixel.+ let mut masked = g;+ masked.screen_mask = Some(ScreenMask { rect: [0.0, 0.0, 0.5, 1.0], radius_px: 0.0 });+ assert!(!masked.screen_trail(RENDER), "{case}: la case d'un bloc ne bouge pas");+ assert_eq!(masked.tilt_pixel_trail(RENDER), Some(trail));+ }}}diff --git a/crates/compositor/src/shaders.hlsl b/crates/compositor/src/shaders.hlslindex b5edd6e26..e23fcde2c 100644--- a/crates/compositor/src/shaders.hlsl+++ b/crates/compositor/src/shaders.hlsl@@ -12,9 +12,9 @@ cbuffer Layer : register(b0)float4 fx; // fx.x = spread ombre (px), fx.y,fx.z libres ; mode 15 : rotation du plan (rad), tangage ; mode 17 : rotation du plan (rad), épaisseurfloat4 src_prev; // src à la frame précédente (flou de mouvement par vélocité) ; mode 15 : hotspot, lacet ; mode 17 : marges du corps (unités du modèle)float4 dst_prev; // dst à la frame précédente ; modes 13 et 15 : rect de clip ; mode 17 : angle du socle, rayon et recouvrement de l'ouverture, pénombre de l'ombre- float4 mb; // mb.x = nombre de taps de motion blur (1 = désactivé) ; modes 15 et 17 : demi-taille du plan, translation- float4 trail_a; // mode 8 : coins TL, TR du plan à la frame précédente (px locaux, comme fx)- float4 trail_b; // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev)+ float4 mb; // mb.x = nombre de taps de motion blur (1 = désactivé) ; modes 15 et 17 : demi-taille du plan, translation ; mode 18 : .z = 1 si le plan est incliné, .w = 1 si son warp est projectif+ float4 trail_a; // mode 8 : coins TL, TR du plan à la frame précédente (px locaux, comme fx) ; mode 18 incliné : en fractions de sortie+ float4 trail_b; // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev) ; mode 18 incliné : en fractions de sortiefloat4 trail_mb; // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; 0 ailleurs};// Mode 15 (curseur modélisé) : le détail des emplacements est dans `frame_geometry.rs`, en tête@@ -264,6 +264,27 @@ float3 quad_inverse(float2 P, float2 c00, float2 c10, float2 c11, float2 c01, flreturn quad_inverse_bilinear(P, c00, c10, c11, c01);}+// Le point (s, t) du plan dans le quad c00->c10->c11->c01 : le warp de `quad_inverse` dans le+// sens direct, prolongé hors du carré unité. Miroir de `TiltedQuad::point_px` (l'homographie de+// `regions::square_to_quad`, ou le bilinéaire des coins).+float2 quad_forward(float2 st, float2 c00, float2 c10, float2 c11, float2 c01, float projective)+{+ if (projective > 0.5)+ {+ float2 p1 = c10 - c00;+ float2 p2 = c11 - c00;+ float2 p3 = c01 - c00;+ float2 d1 = p1 - p2;+ float2 d2 = p3 - p2;+ float2 d3 = p2 - p1 - p3;+ float den = d1.x * d2.y - d2.x * d1.y;+ float g = (d3.x * d2.y - d2.x * d3.y) / den;+ float h = (d1.x * d3.y - d3.x * d1.y) / den;+ return c00 + (p1 * (1.0 + g) * st.x + p3 * (1.0 + h) * st.y) / (g * st.x + h * st.y + 1.0);+ }+ return c00 + st.x * (c10 - c00) + st.y * (c01 - c00) + st.x * st.y * (c00 - c10 - c01 + c11);+}+// Un échantillon de l'écran incliné (mode 8) : la vidéo nette, fondue vers la pyramide de// profondeur de champ (t2) au-delà d'un demi-texel de cercle de confusion `coc`. Sous ce seuil,// l'échantillon net d'avant, à l'octet.@@ -2055,11 +2076,15 @@ float4 ps_main(VSOut i) : SV_Target{// mode 18 : l'écran CADRÉ (ombre, cadre, métrage, appareil) flouté comme UN objet rigide// (`FrameGeometry::screen_trail`). t2 = son rendu isolé, prémultiplié, à la taille de la- // sortie ; sa boîte va de `dst_prev` (frame précédente) à `fx` (courante), fractions de sortie.- // Chaque tap relit, dans le rendu courant, le point de l'objet qui couvrait ce pixel plus tôt- // sur la trajectoire. Un point hors de la sortie n'a pas été rendu : dans l'ouverture arrondie- // de l'écran (`quad_px`, `radius_px`, 2 px en retrait : la lunette mord dessus), on relit le- // métrage (`src` = la coupe) ; ailleurs (un bout de cadre hors champ), le tap est écarté.+ // sortie. Chaque tap retrouve le point de l'objet qui couvrait ce pixel plus tôt sur la+ // trajectoire (`f`, fractions de l'écran) et le relit là où il est dessiné maintenant (`q`,+ // fractions de sortie). À plat, la boîte va de `dst_prev` (frame précédente) à `fx`+ // (courante). Incliné (`mb.z` = 1), le plan : ses coins TL, TR / BR, BL courants dans+ // `fx`/`src_prev`, ceux d'avant dans `trail_a`/`trail_b` ; le tap interpole les coins, et le+ // warp du plan (`mb.w`, celui du mode 8) fait l'aller (le pixel vers le plan) et le retour (le+ // plan vers le rendu courant). Un point hors de la sortie n'a pas été rendu : dans l'ouverture+ // arrondie de l'écran (`quad_px`, `radius_px`, 2 px en retrait : la lunette mord dessus), on+ // relit le métrage (`src` = la coupe) ; ailleurs (un bout de cadre hors champ), le tap est écarté.if (mode > 17.5){int taps = (int) mb.x;@@ -2069,9 +2094,21 @@ float4 ps_main(VSOut i) : SV_Target{if (k >= taps) break;float a = saturate(mb.y) * (1.0 - (float) k / (float) (taps - 1));- float4 r = lerp(fx, dst_prev, a);- float2 f = (i.pout - r.xy) / r.zw;- float2 q = fx.xy + f * fx.zw;+ float2 f;+ float2 q;+ if (mb.z > 0.5)+ {+ float4 ta = lerp(fx, trail_a, a);+ float4 tb = lerp(src_prev, trail_b, a);+ f = quad_inverse(i.pout, ta.xy, ta.zw, tb.xy, tb.zw, mb.w).xy;+ q = quad_forward(f, fx.xy, fx.zw, src_prev.xy, src_prev.zw, mb.w);+ }+ else+ {+ float4 r = lerp(fx, dst_prev, a);+ f = (i.pout - r.xy) / r.zw;+ q = fx.xy + f * fx.zw;+ }if (all(q >= 0.0) && all(q <= 1.0)){acc += texImg.SampleLevel(samp, q, 0.0);@@ -2383,13 +2420,14 @@ float4 ps_main(VSOut i) : SV_Target// Flou de mouvement, celui du mode 0 : l'UV que CE pixel montrait à la frame précédente,// par le même warp inverse sur les coins d'avant (`trail_a`/`trail_b`), puis `taps`// échantillons de celui-là à celui-ci, raccourcis de la force. Borné à une frame. Hors du- // plan d'avant, le warp prolongé donne encore le bon point (sa racine proche).+ // plan d'avant, le warp prolongé donne encore le bon point (sa racine proche). Le+ // mouvement se mesure entre les deux points NON bornés : `uv` l'est, et sur le bord d'un+ // plan immobile, `uv − uv_prev` aurait flouté la frange.int taps = (int) trail_mb.x;if (taps > 1 && trail_mb.y > 0.001){float3 rp = quad_inverse(i.local, trail_a.xy, trail_a.zw, trail_b.xy, trail_b.zw, dst_prev.w);- float2 uv_prev = float2(lerp(src.x, src.z, rp.x), lerp(src.y, src.w, rp.y));- float2 duv = (uv - uv_prev) * saturate(trail_mb.y);+ float2 duv = (r.xy - rp.xy) * (src.zw - src.xy) * saturate(trail_mb.y);if (dot(duv, duv) >= 1e-9){float3 acc = 0.0;diff --git a/crates/compositor/src/shaders.metal b/crates/compositor/src/shaders.metalindex 336647ca3..0472066c7 100644--- a/crates/compositor/src/shaders.metal+++ b/crates/compositor/src/shaders.metal@@ -56,9 +56,9 @@ struct Layerfloat4 fx; // fx.x = spread ombre (px), fx.y,fx.z libres ; mode 15 : rotation du plan (rad), tangage ; mode 17 : rotation du plan (rad), épaisseurfloat4 src_prev; // src à la frame précédente (flou de mouvement par vélocité) ; mode 15 : hotspot, lacet ; mode 17 : marges du corps (unités du modèle)float4 dst_prev; // dst à la frame précédente ; modes 13 et 15 : rect de clip ; mode 17 : angle du socle, rayon et recouvrement de l'ouverture, pénombre de l'ombre- float4 mb; // mb.x = nombre de taps de motion blur (1 = désactivé) ; modes 15 et 17 : demi-taille du plan, translation- float4 trail_a; // mode 8 : coins TL, TR du plan à la frame précédente (px locaux, comme fx)- float4 trail_b; // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev)+ float4 mb; // mb.x = nombre de taps de motion blur (1 = désactivé) ; modes 15 et 17 : demi-taille du plan, translation ; mode 18 : .z = 1 si le plan est incliné, .w = 1 si son warp est projectif+ float4 trail_a; // mode 8 : coins TL, TR du plan à la frame précédente (px locaux, comme fx) ; mode 18 incliné : en fractions de sortie+ float4 trail_b; // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev) ; mode 18 incliné : en fractions de sortiefloat4 trail_mb; // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; 0 ailleurs};// Mode 15 (curseur modélisé) : le détail des emplacements est dans `frame_geometry.rs`, en tête@@ -312,6 +312,26 @@ inline float3 quad_inverse(float2 P, float2 c00, float2 c10, float2 c11, float2return quad_inverse_bilinear(P, c00, c10, c11, c01);}+// Le point (s, t) du plan dans le quad : le warp de `quad_inverse` dans le sens direct, prolongé+// hors du carré unité. Miroir du HLSL et de `TiltedQuad::point_px`.+inline float2 quad_forward(float2 st, float2 c00, float2 c10, float2 c11, float2 c01, float projective)+{+ if (projective > 0.5)+ {+ float2 p1 = c10 - c00;+ float2 p2 = c11 - c00;+ float2 p3 = c01 - c00;+ float2 d1 = p1 - p2;+ float2 d2 = p3 - p2;+ float2 d3 = p2 - p1 - p3;+ float den = d1.x * d2.y - d2.x * d1.y;+ float g = (d3.x * d2.y - d2.x * d3.y) / den;+ float h = (d1.x * d3.y - d3.x * d1.y) / den;+ return c00 + (p1 * (1.0 + g) * st.x + p3 * (1.0 + h) * st.y) / (g * st.x + h * st.y + 1.0);+ }+ return c00 + st.x * (c10 - c00) + st.y * (c01 - c00) + st.x * st.y * (c00 - c10 - c01 + c11);+}+// Un échantillon de l'écran incliné (mode 8) : la vidéo nette, fondue vers la pyramide de// profondeur de champ (texture(2)) au-delà d'un demi-texel de cercle de confusion `coc`. Sous ce// seuil, l'échantillon net d'avant, à l'octet. Miroir de `tilted_sample` (HLSL).@@ -1941,7 +1961,9 @@ fragment float4 ps_main(VSOut i [[stage_in]],{// mode 18 : l'écran CADRÉ (ombre, cadre, métrage, appareil) flouté comme UN objet rigide// (`FrameGeometry::screen_trail`), port 1:1 du HLSL. texImg = son rendu isolé, prémultiplié,- // à la taille de la sortie ; sa boîte va de `dst_prev` (frame précédente) à `fx` (courante).+ // à la taille de la sortie. À plat, sa boîte va de `dst_prev` (frame précédente) à `fx`+ // (courante) ; incliné (`mb.z` = 1), les coins du plan vont de `trail_a`/`trail_b` à+ // `fx`/`src_prev`, et le warp du plan (`mb.w`, celui du mode 8) fait l'aller et le retour.// Hors de la sortie rien n'a été rendu : dans l'ouverture arrondie de l'écran (`quad_px`,// `radius_px`, 2 px en retrait) on relit le métrage (`src` = la coupe), ailleurs le tap est écarté.if (layer.mode > 17.5)@@ -1953,9 +1975,22 @@ fragment float4 ps_main(VSOut i [[stage_in]],{if (k >= taps) break;float a = saturate(layer.mb.y) * (1.0 - float(k) / float(taps - 1));- float4 r = mix(layer.fx, layer.dst_prev, a);- float2 f = (i.pout - r.xy) / r.zw;- float2 q = layer.fx.xy + f * layer.fx.zw;+ float2 f;+ float2 q;+ if (layer.mb.z > 0.5)+ {+ float4 ta = mix(layer.fx, layer.trail_a, a);+ float4 tb = mix(layer.src_prev, layer.trail_b, a);+ f = quad_inverse(i.pout, ta.xy, ta.zw, tb.xy, tb.zw, layer.mb.w).xy;+ q = quad_forward(f, layer.fx.xy, layer.fx.zw,+ layer.src_prev.xy, layer.src_prev.zw, layer.mb.w);+ }+ else+ {+ float4 r = mix(layer.fx, layer.dst_prev, a);+ f = (i.pout - r.xy) / r.zw;+ q = layer.fx.xy + f * layer.fx.zw;+ }if (all(q >= 0.0) && all(q <= 1.0)){acc += texImg.sample(samp, q, level(0.0));@@ -2152,14 +2187,15 @@ fragment float4 ps_main(VSOut i [[stage_in]],float3 rgb = tilted_sample(uv, coc, texY, texUV, texImg);// Flou de mouvement, celui du mode 0 : l'UV que CE pixel montrait à la frame précédente,// par le même warp inverse sur les coins d'avant (`trail_a`/`trail_b`), puis `taps`- // échantillons de celui-là à celui-ci, raccourcis de la force. Borné à une frame.+ // échantillons de celui-là à celui-ci, raccourcis de la force. Borné à une frame. Le+ // mouvement se mesure entre les deux points NON bornés (cf. HLSL).int taps = int(layer.trail_mb.x);if (taps > 1 && layer.trail_mb.y > 0.001){float3 rp = quad_inverse(i.local, layer.trail_a.xy, layer.trail_a.zw,layer.trail_b.xy, layer.trail_b.zw, layer.dst_prev.w);- float2 uv_prev = float2(mix(layer.src.x, layer.src.z, rp.x), mix(layer.src.y, layer.src.w, rp.y));- float2 duv = (uv - uv_prev) * clamp(layer.trail_mb.y, 0.0, 1.0);+ float2 duv = (r.xy - rp.xy) * (layer.src.zw - layer.src.xy)+ * clamp(layer.trail_mb.y, 0.0, 1.0);if (dot(duv, duv) >= 1e-9){float3 acc = float3(0.0);diff --git a/crates/compositor/src/vk_shaders/layer.wgsl b/crates/compositor/src/vk_shaders/layer.wgslindex 6ca239649..dfeed6ea7 100644--- a/crates/compositor/src/vk_shaders/layer.wgsl+++ b/crates/compositor/src/vk_shaders/layer.wgsl@@ -27,9 +27,9 @@ struct Layer {fx: vec4<f32>, // mode 2 : spread ombre en px ; mode 5 : (direction xy, temps programme replie, mouvement 0..3) ; modes 8/12/13/14 : coins TL,TR du quad projeté ; mode 9 : hampe de la flèche ; mode 10 : (flou?, rayon/bloc px, ovale?, teinté?) ; mode 15 : (rotation du plan X, Y, Z en rad, tangage) ; mode 17 : (rotation du plan X, Y, Z en rad, epaisseur du corps)src_prev: vec4<f32>, // modes 8/12/13/14 : coins BR,BL du quad projeté ; mode 9 : barbe 1 ; mode 10 incliné : coins BR,BL du masque ; mode 15 : (hotspot du dessus, repere du plan en px ; lacet) ; mode 17 : marges du corps (gauche, haut, droite, bas ; unites du modele)dst_prev: vec4<f32>, // mode 8 : .xy = taille du plan en px AVANT projection (le rayon y vit), .z = 1 si coins hauts carres (sous un cadre), .w = 1 si warp projectif ; mode 14 : .xy = taille du plan du cadre, .z = hauteur de la barre, .w = epaisseur du filet (px du plan) ; modes 13 et 15 : rect de clip ; mode 9 : barbe 2 ; mode 10 incliné : coins TL,TR du masque ; mode 17 : (angle du socle depuis le plan en rad, rayon de l'ouverture et recouvrement de la lunette en unites du modele, penombre de l'ombre ou 0)- mb: vec4<f32>, // mode 8 : [gx, gy, z_focus, k], profondeur du plan et flou (texels source) par px d'ecart, k = 0 coupe ; mode 0 : .x taps, .y force du flou, .w = 1 si coins hauts carres (sous un cadre) ; mode 5 : mb.x = aspect w/h de la sortie (fond anime) ; mode 12 : mb.y = spread de la pénombre en px ; mode 9 : mb.y = demi-épaisseur du trait en px ; mode 10 : mb.z = 1 si masque incliné, mb.w = 1 si son warp est projectif ; mode 13 : mb.x = 1 si warp projectif ; mode 14 : couleur du filet (alpha droit) ; modes 15 et 17 : .xy = demi-taille du plan dans son repere (px pour le 15, unites pour le 17), .zw = translation du plan (repere camera, px)- trail_a: vec4<f32>, // mode 8 : coins TL, TR du plan a la frame precedente (px locaux, comme fx)- trail_b: vec4<f32>, // mode 8 : coins BR, BL du plan a la frame precedente (comme src_prev)+ mb: vec4<f32>, // mode 8 : [gx, gy, z_focus, k], profondeur du plan et flou (texels source) par px d'ecart, k = 0 coupe ; mode 0 : .x taps, .y force du flou, .w = 1 si coins hauts carres (sous un cadre) ; mode 5 : mb.x = aspect w/h de la sortie (fond anime) ; mode 12 : mb.y = spread de la pénombre en px ; mode 9 : mb.y = demi-épaisseur du trait en px ; mode 10 : mb.z = 1 si masque incliné, mb.w = 1 si son warp est projectif ; mode 13 : mb.x = 1 si warp projectif ; mode 14 : couleur du filet (alpha droit) ; modes 15 et 17 : .xy = demi-taille du plan dans son repere (px pour le 15, unites pour le 17), .zw = translation du plan (repere camera, px) ; mode 18 : .z = 1 si le plan est incline, .w = 1 si son warp est projectif+ trail_a: vec4<f32>, // mode 8 : coins TL, TR du plan a la frame precedente (px locaux, comme fx) ; mode 18 incline : en fractions de sortie+ trail_b: vec4<f32>, // mode 8 : coins BR, BL du plan a la frame precedente (comme src_prev) ; mode 18 incline : en fractions de sortietrail_mb: vec4<f32>, // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; 0 ailleurs}@@ -104,9 +104,11 @@ fn sample_yuv_level(uv: vec2<f32>) -> vec3<f32> {// Mode 18 -- l'ecran CADRE (ombre, cadre, metrage, appareil) floute comme UN objet rigide// (`FrameGeometry::screen_trail`), port 1:1 du HLSL. Binding 4 = son rendu isole, premultiplie,-// a la taille de la sortie ; sa boite va de `dst_prev` (frame precedente) a `fx` (courante).-// Chaque tap relit, dans le rendu courant, le point de l'objet qui couvrait ce pixel plus tot sur-// la trajectoire. Hors de la sortie rien n'a ete rendu : dans l'ouverture arrondie de l'ecran+// a la taille de la sortie. Chaque tap retrouve le point de l'objet qui couvrait ce pixel plus tot+// sur la trajectoire (`f`) et le relit la ou il est dessine maintenant (`q`). A plat, sa boite va+// de `dst_prev` (frame precedente) a `fx` (courante) ; incline (`mb.z` = 1), les coins du plan+// vont de `trail_a`/`trail_b` a `fx`/`src_prev`, et le warp du plan (`mb.w`, celui du mode 8) fait+// l'aller et le retour. Hors de la sortie rien n'a ete rendu : dans l'ouverture arrondie de l'ecran// (`quad_px`, `radius_px`, 2 px en retrait) on relit le metrage (`src` = la coupe), ailleurs le// tap est ecarte.fn screen_trail(pout: vec2<f32>) -> vec4<f32> {@@ -116,9 +118,18 @@ fn screen_trail(pout: vec2<f32>) -> vec4<f32> {for (var k: i32 = 0; k < 16; k = k + 1) {if k >= taps { break; }let a = clamp(layer.mb.y, 0.0, 1.0) * (1.0 - f32(k) / f32(taps - 1));- let r = mix(layer.fx, layer.dst_prev, a);- let f = (pout - r.xy) / r.zw;- let q = layer.fx.xy + f * layer.fx.zw;+ var f: vec2<f32>;+ var q: vec2<f32>;+ if layer.mb.z > 0.5 {+ let ta = mix(layer.fx, layer.trail_a, a);+ let tb = mix(layer.src_prev, layer.trail_b, a);+ f = quad_inverse(pout, ta.xy, ta.zw, tb.xy, tb.zw, layer.mb.w).xy;+ q = quad_forward(f, layer.fx.xy, layer.fx.zw, layer.src_prev.xy, layer.src_prev.zw, layer.mb.w);+ } else {+ let r = mix(layer.fx, layer.dst_prev, a);+ f = (pout - r.xy) / r.zw;+ q = layer.fx.xy + f * layer.fx.zw;+ }let rendered = all(q >= vec2<f32>(0.0)) && all(q <= vec2<f32>(1.0));// Un `if`, pas un `select` : `select` evalue ses deux branches, soit trois lectures du// metrage et une SDF par tap pour rien. Parite HLSL / MSL.@@ -342,6 +353,24 @@ fn quad_inverse(P: vec2<f32>, c00: vec2<f32>, c10: vec2<f32>, c11: vec2<f32>, c0return quad_inverse_bilinear(P, c00, c10, c11, c01);}+// Le point (s, t) du plan dans le quad : le warp de `quad_inverse` dans le sens direct, prolonge+// hors du carre unite. Miroir du HLSL et de `TiltedQuad::point_px`.+fn quad_forward(st: vec2<f32>, c00: vec2<f32>, c10: vec2<f32>, c11: vec2<f32>, c01: vec2<f32>, projective: f32) -> vec2<f32> {+ if projective > 0.5 {+ let p1 = c10 - c00;+ let p2 = c11 - c00;+ let p3 = c01 - c00;+ let d1 = p1 - p2;+ let d2 = p3 - p2;+ let d3 = p2 - p1 - p3;+ let den = d1.x * d2.y - d2.x * d1.y;+ let g = (d3.x * d2.y - d2.x * d3.y) / den;+ let h = (d1.x * d3.y - d3.x * d1.y) / den;+ return c00 + (p1 * (1.0 + g) * st.x + p3 * (1.0 + h) * st.y) / (g * st.x + h * st.y + 1.0);+ }+ return c00 + st.x * (c10 - c00) + st.y * (c01 - c00) + st.x * st.y * (c00 - c10 - c01 + c11);+}+// Un echantillon de l'ecran incline (mode 8) : la video nette, fondue vers la pyramide de// profondeur de champ (binding 4, a la place du masque webcam) au-dela d'un demi-texel de cercle// de confusion `coc`. Sous ce seuil, l'echantillon net d'avant, a l'octet. Miroir de@@ -2014,17 +2043,14 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {var tilt_rgb = tilted_sample(uv, coc);// Flou de mouvement, celui du mode 0 (cf. HLSL) : l'UV que CE pixel montrait a la frame// precedente, par le meme warp inverse sur les coins d'avant (`trail_a`/`trail_b`), puis- // `taps` echantillons de celui-la a celui-ci, raccourcis de la force. Borne a une frame.+ // `taps` echantillons de celui-la a celui-ci, raccourcis de la force. Borne a une frame. Le+ // mouvement se mesure entre les deux points NON bornes (cf. HLSL).let trail_taps = i32(layer.trail_mb.x);if trail_taps > 1 && layer.trail_mb.y > 0.001 {let rp = quad_inverse(i.local, layer.trail_a.xy, layer.trail_a.zw, layer.trail_b.xy, layer.trail_b.zw, layer.dst_prev.w,);- let uv_prev = vec2<f32>(- mix(layer.src.x, layer.src.z, rp.x),- mix(layer.src.y, layer.src.w, rp.y),- );- let duv = (uv - uv_prev) * clamp(layer.trail_mb.y, 0.0, 1.0);+ let duv = (r.xy - rp.xy) * (layer.src.zw - layer.src.xy) * clamp(layer.trail_mb.y, 0.0, 1.0);if dot(duv, duv) >= 1e-9 {var acc = vec3<f32>(0.0);let step = 1.0 / f32(trail_taps - 1);diff --git a/crates/compositor/tests/device_frame_render.rs b/crates/compositor/tests/device_frame_render.rsindex 6b649a005..ebf428de5 100644--- a/crates/compositor/tests/device_frame_render.rs+++ b/crates/compositor/tests/device_frame_render.rs@@ -574,6 +574,53 @@ fn the_device_follows_the_tilt_and_the_orbit_camera() {}}+/// Le flou de mouvement prend l'écran CADRÉ en bloc, à plat comme sous une caméra 3D : pendant la+/// rampe du zoom, l'appareil et son ombre filent avec le métrage, donc des pixels HORS du métrage+/// changent avec le flou. Au palier, le rendu flou est le rendu net, à l'octet. Sous un angle fixe+/// ou la caméra en orbite, seul le métrage était flouté : l'appareil restait net autour de lui.+#[test]+fn the_device_trails_with_the_screen_under_motion_blur() {+ let Some(gpu) = gpu() else { return };+ let comp = Compositor::new_sized(&gpu, W, H).expect("compositor");+ let blue = FakeFrame::new(&gpu, SRC, Tint::Blue);+ let orange = FakeFrame::new(&gpu, SRC, Tint::Orange);+ // Zoom ×1,6 de 2 à 6 s : sa rampe d'entrée court de 1,14 à 2 s, vitesse au plus fort vers 1,26 s.+ // Le petit rect garde l'appareil dans l'image pendant la rampe.+ let json = |device: &str, rotation: &str, blur: f32| {+ let json = with_rect(&scene_json(device, rotation, 0.6, NO_CURSOR, (W, H)), CLIPS[0].1)+ .replace(r#""startSec":0,"endSec":10,"scale":1,"#, r#""startSec":2,"endSec":6,"scale":1.6,"#)+ .replace(r#""roundnessFrac":0.02,"motionBlur":0"#, &format!(r#""roundnessFrac":0.02,"motionBlur":{blur}"#));+ assert!(json.contains(r#""scale":1.6"#), "la substitution doit poser la rampe");+ json+ };+ for device in ["laptop", "window"] {+ for rotation in ["null", r#""iso""#, r#""follow-cursor""#] {+ let case = format!("{device} {rotation}");+ let still = |blur| render(&comp, &blue, &json(device, rotation, blur), None, 4.0);+ assert!(still(0.0) == still(1.0), "{case} : immobile, le flou ne doit rien changer");+ let t = 1.3;+ let sharp = render(&comp, &blue, &json(device, rotation, 0.0), None, t);+ let tint = render(&comp, &orange, &json(device, rotation, 0.0), None, t);+ let blurred = render(&comp, &blue, &json(device, rotation, 1.0), None, t);+ // Hors du métrage (le pixel net ne dépend pas de la teinte de la source) : ce qui change+ // avec le flou est l'appareil, son ombre, ou le fond qu'ils découvrent en filant.+ let smeared = (0..(W * H) as usize)+ .filter(|&i| {+ let p = |b: &[u8]| [b[i * 4], b[i * 4 + 1], b[i * 4 + 2]];+ p(&sharp) == p(&tint) && p(&sharp).iter().zip(p(&blurred)).any(|(a, b)| a.abs_diff(b) > 8)+ })+ .count();+ println!("{case:<24} {smeared:>7} px hors du métrage changent avec le flou");+ if let Some(dir) = out_dir("OPENSCREEN_DEVICE_OUT") {+ let name = format!("trail-{device}-{}", rotation.trim_matches('"'));+ save(&dir, &format!("{name}-sharp"), &sharp, (W, H));+ save(&dir, &format!("{name}-blurred"), &blurred, (W, H));+ }+ assert!(smeared > (W * H) as usize / 200, "{case} : le cadre reste net pendant le zoom ({smeared} px)");+ }+ }+}+/// Le cadre porte l'ombre, pas l'écran : avec l'ombre allumée, le fond s'assombrit AUTOUR de/// l'appareil, y compris sous le socle du portable, qui descend plus bas que l'écran.#[test]diff --git a/docs/3d-effects-v2.md b/docs/3d-effects-v2.mdindex f52e52f68..771704a22 100644--- a/docs/3d-effects-v2.md+++ b/docs/3d-effects-v2.md@@ -167,10 +167,14 @@ lointain.- **`swing-clicks`** : à refaire sur `camera.rs`, l'orbite en donne la mécanique.- **`dolly`** (vertigo) : la distance de l'œil par frame, que `TiltedQuad::perspective` saitdéjà transporter.-- **Flou de mouvement de la visée** : le mode 8 a le flou du mode 0, borné à une frame, sur le plan- d'une frame plus tôt (boîte du zoom, rotation de base, caméra réelle d'avant ;- `FrameGeometry::tilt_trail`, `LayerCB::trail_*`). La parallaxe et l'impact n'y entrent pas,- comme le focus au mode 0. Un masque de confidentialité couvre alors le secret aux deux frames.+- **Flou de mouvement de la visée** : l'écran incliné a le flou de l'écran droit, borné à une frame,+ vers le plan d'une frame plus tôt (boîte du zoom, rotation de base, caméra réelle d'avant ;+ `FrameGeometry::tilt_trail`). Comme à plat, l'écran CADRÉ file en bloc : ombre, cadre, métrage et+ appareil passent par le rendu isolé du mode 18, qui interpole les coins du plan et suit son warp,+ bilinéaire ou projectif comme au mode 8 (`screen_trail_cb`). Seul un masque de bloc garde le flou+ par pixel du mode 8+ (`tilt_pixel_trail`, `LayerCB::trail_*`). La parallaxe et l'impact n'y entrent pas, comme le+ focus au mode 0. Un masque de confidentialité couvre alors le secret aux deux frames.- **Lumière du curseur modélisé** : elle reste fixée à la caméra ; l'œil en orbite la déplace aveclui. À fixer au monde avec le propriétaire du mode 15.