Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

fix(compositor): 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.rs
index 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 a
diff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rs
index 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.rs
index 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.rs
index 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.hlsl
index 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), épaisseur
float4 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 sortie
float4 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, fl
return 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.metal
index 336647ca3..0472066c7 100644
--- a/crates/compositor/src/shaders.metal
+++ b/crates/compositor/src/shaders.metal
@@ -56,9 +56,9 @@ struct Layer
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), épaisseur
float4 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 sortie
float4 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, float2
return 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.wgsl
index 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 sortie
trail_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>, c0
return 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.rs
index 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.md
index 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` sait
dé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 avec
lui. À fixer au monde avec le propriétaire du mode 15.