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): drop unsolvable trail taps and keep depth of field off canvas

EtienneLescot6c144fe6fd75
diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rs
index cdb72e881..198e6e637 100644
--- a/crates/compositor/src/compositor_linux.rs
+++ b/crates/compositor/src/compositor_linux.rs
@@ -245,7 +245,7 @@ struct WebcamMask {
}
/// Pyramide de profondeur de champ (cf. `Compositor::dof_pyramid`). `_tex` garde la
-/// texture en vie ; `view` porte tous les niveaux (binding 4 du mode 8), `mips` un
+/// texture en vie ; `view` porte tous les niveaux (binding 6 des modes 8 et 18), `mips` un
/// niveau chacune (cible du remplissage puis de `generate_mips`).
struct DofPyramid {
_tex: wgpu::Texture,
@@ -471,6 +471,9 @@ impl Compositor {
// plans, et renumeroter aurait touche tous les bind groups
// pour un gain nul.
tex_entry(5),
+ // Pyramide de profondeur de champ (modes 8 et 18), `dummy` ailleurs : le
+ // mode 18 lit a la fois le metrage, son rendu isole (binding 4) et elle.
+ tex_entry(6),
],
});
let pipeline_layout = gpu.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
@@ -1275,18 +1278,18 @@ impl Compositor {
planes: Option<(&wgpu::TextureView, &wgpu::TextureView, &wgpu::TextureView)>,
dummy: &wgpu::TextureView,
) -> (wgpu::Buffer, wgpu::BindGroup) {
- self.make_bind_b4(cb, planes, dummy, None)
+ self.make_bind_b4(cb, planes, dummy, None, None)
}
- /// `make_bind`, binding 4 impose. Seul le mode 8 s'en sert, pour y lier la pyramide
- /// de profondeur de champ a la place du masque webcam qu'il ne lit pas -- jamais le
- /// binding 1, qui porte la luma.
+ /// `make_bind`, binding 4 impose (le rendu isole du mode 18, a la place du masque webcam
+ /// qu'il ne lit pas), et la pyramide de profondeur de champ en binding 6 (modes 8 et 18).
fn make_bind_b4(
&self,
cb: &LayerCB,
planes: Option<(&wgpu::TextureView, &wgpu::TextureView, &wgpu::TextureView)>,
dummy: &wgpu::TextureView,
b4: Option<&wgpu::TextureView>,
+ dof: Option<&wgpu::TextureView>,
) -> (wgpu::Buffer, wgpu::BindGroup) {
let uniform = self.gpu.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("layer-uniform"),
@@ -1331,6 +1334,10 @@ impl Compositor {
binding: 5,
resource: wgpu::BindingResource::TextureView(v),
},
+ wgpu::BindGroupEntry {
+ binding: 6,
+ resource: wgpu::BindingResource::TextureView(dof.unwrap_or(dummy)),
+ },
],
});
(uniform, bind)
@@ -2206,12 +2213,13 @@ impl Compositor {
// Bind group construit AVANT le pass (doit vivre pendant tout le pass) ;
// `_screen_uniform` garde le buffer uniforme en vie (reference par le bind).
let dummy = self.dummy_view();
- // Binding 4 EXPLICITE sur le mode 8 : la pyramide si l'effet tourne, sinon le
- // repli habituel (`k = 0`, le shader n'y lit rien).
+ // Binding 6 du mode 8 : la pyramide si l'effet tourne, sinon `dummy` (`k = 0`, le
+ // shader n'y lit rien).
let (_screen_uniform, screen_bind) = self.make_bind_b4(
&screen_layer,
Some((&sy, &su, &sv)),
&dummy,
+ None,
dof_pyramid.map(|p| &p.view),
);
// Remplissage de la pyramide : UN draw du mode 0 en UV plein vers son niveau 0
@@ -2272,13 +2280,14 @@ impl Compositor {
// 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, droit ou incline ; binding 4 = ce rendu, les plans = le
- // metrage.
+ // metrage, binding 6 = la pyramide, pour le relire hors de la sortie comme le mode 8.
let trail = g.screen_trail([rw, rh]).then(|| {
self.make_bind_b4(
- &g.screen_trail_cb([rw, rh]),
+ &g.screen_trail_cb([rw, rh], dof),
Some((&sy, &su, &sv)),
&dummy,
Some(&self.trail_view),
+ dof_pyramid.map(|p| &p.view),
)
});
@@ -5029,6 +5038,120 @@ mod tests {
}
}
+ /// Un seul ecran dans `rect` (fractions de la sortie `out`), zoome x`scale` sous `iso` de 2 a
+ /// 6 s, fond uni sans ombre ni padding. Meme scene que `tests/screen_trail_render.rs` (D3D11).
+ fn trail_scene_json(rect: [f32; 4], out: (u32, u32), scale: f32, blur: f32, dof: bool) -> String {
+ let [x, y, w, h] = rect;
+ let (ow, oh) = out;
+ format!(
+ r##"{{"clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],
+ "layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false,
+ "screenRect":{{"x":{x},"y":{y},"width":{w},"height":{h}}}}},
+ "effects":{{"padding":0,"blur":false,"shadow":0,"roundnessFrac":0.02,"motionBlur":{blur},"depthOfField":{dof}}},
+ "background":{{"kind":"color","color":"#6070a0"}},
+ "zoomRegions":[{{"clipIndex":0,"startSec":2,"endSec":6,"scale":{scale},"focusX":0.5,"focusY":0.5,"focusMode":"manual","rotation":"iso"}}],
+ "annotations":[],
+ "cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},
+ "cropByClip":[null],
+ "output":{{"width":{ow},"height":{oh},"fps":30}}}}"##
+ )
+ }
+
+ fn compose_trail(comp: &Compositor, screen: &FakeFrame, json: &str, t: f32) -> Vec<u8> {
+ let scene = Scene::from_json(json).expect("scene json");
+ comp.set_live_params(live_params_from_scene(&scene));
+ comp.set_has_webcam(false);
+ comp.set_scene(Some(scene));
+ let mut cfg = Cfg::c8();
+ cfg.bg_blur = 0.0;
+ cfg.zoom = false;
+ cfg.layout_anim = false;
+ cfg.cursor = false;
+ cfg.mblur_n = 1;
+ cfg.shadow = false;
+ unsafe {
+ comp.set_timeline_time(Some(t));
+ comp.compose_frame(screen.as_ptr(), screen.as_ptr(), 0.0, &cfg).expect("compose_frame");
+ comp.readback_direct().expect("readback_direct").2
+ }
+ }
+
+ /// Un tap du mode 18 dont le warp inverse n'a PAS de solution (au-dela du pli du warp
+ /// bilineaire d'`iso`) est ecarte : il valait l'origine du plan, renvoyee sur le coin
+ /// haut-gauche de l'ecran courant, et le fond loin de l'ecran prenait la couleur de ce coin
+ /// (un repere masque par l'arrondi y reparaissait). Petit ecran centre (15 %), zoom x1,6 :
+ /// loin de l'ecran, le rendu floute reste le fond, au bit pres. Pendant D3D11 :
+ /// `tests/screen_trail_render.rs`.
+ #[test]
+ fn unsolvable_trail_taps_leave_the_background_alone() {
+ let Some(gpu) = gpu() else { return };
+ let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");
+ // Metrage rouge, repere vert dans son coin haut-gauche.
+ let (w, h) = (640u32, 360u32);
+ let marker = |col: u32, row: u32| col < 48 && row < 48;
+ let y: Vec<u8> = (0..w * h).map(|i| if marker(i % w, i / w) { 173 } else { 63 }).collect();
+ let uv: Vec<u8> = (0..w * (h / 2))
+ .map(|i| {
+ let [u, v] = if marker(i % w & !1, i / w * 2) { [42, 26] } else { [102, 240] };
+ if i % 2 == 0 { u } else { v }
+ })
+ .collect();
+ let screen = FakeFrame::from_planes(&gpu, w, h, &y, &uv);
+ let json = |blur| trail_scene_json([0.425, 0.425, 0.15, 0.15], (1280, 720), 1.6, blur, false);
+ let far = |x: u32, y: u32| !(320..960).contains(&x) || !(180..540).contains(&y);
+ let mut leaks = 0;
+ for t in [1.5, 1.7, 1.9, 6.1] {
+ let sharp = compose_trail(&comp, &screen, &json(0.0), t);
+ let blurred = compose_trail(&comp, &screen, &json(1.0), t);
+ let n = (0..1280 * 720u32)
+ .filter(|&i| far(i % 1280, i / 1280))
+ .filter(|&i| sharp[i as usize * 4..][..3] != blurred[i as usize * 4..][..3])
+ .count();
+ eprintln!("t={t} : {n} px du fond changent avec le flou");
+ leaks += n;
+ }
+ assert_eq!(leaks, 0, "le flou de mouvement a peint loin de l'ecran");
+ }
+
+ /// Hors de la sortie, le mode 18 relit le metrage comme le mode 8 l'a dessine, profondeur de
+ /// champ comprise : le meme ecran physique, zoome x2 sous `iso`, rendu sur la sortie et au
+ /// centre d'une sortie deux fois plus grande (ou rien ne sort du cadre), coincide aux bords de
+ /// la sortie. Le repli lisait le metrage NET. Pendant D3D11 : `tests/screen_trail_render.rs`.
+ #[test]
+ fn off_canvas_trail_taps_keep_the_depth_of_field() {
+ let Some(gpu) = gpu() else { return };
+ let (w, h) = (640u32, 360u32);
+ // Rayures noires et blanches de 2 px : la profondeur de champ les grise.
+ let screen = FakeFrame::new(&gpu, w, h, |col, _| if col / 2 % 2 == 0 { Y_BLACK } else { Y_WHITE });
+ let (ow, oh) = (1280u32, 720u32);
+ let normal = Compositor::new_sized(&gpu, ow, oh).expect("Compositor::new_sized");
+ let padded = Compositor::new_sized(&gpu, 2 * ow, 2 * oh).expect("Compositor::new_sized");
+ let json = |k: f32, dof| {
+ let r = [0.5 - 0.4 / k, 0.5 - 0.4 / k, 0.8 / k, 0.8 / k];
+ trail_scene_json(r, ((ow as f32 * k) as u32, (oh as f32 * k) as u32), 2.0, 1.0, dof)
+ };
+ let edges: Vec<(u32, u32)> =
+ (oh / 4..oh * 3 / 4).flat_map(|y| (0..24).chain(ow - 24..ow).map(move |x| (x, y))).collect();
+ let at = |rgba: &[u8], w: u32, (x, y): (u32, u32)| rgba[((y * w + x) * 4) as usize];
+ for t in [1.5, 1.7] {
+ let a = compose_trail(&normal, &screen, &json(1.0, true), t);
+ let b = compose_trail(&padded, &screen, &json(2.0, true), t);
+ let net = compose_trail(&normal, &screen, &json(1.0, false), t);
+ let crop = |(x, y): (u32, u32)| (x + ow / 2, y + oh / 2);
+ let diffs: Vec<u8> = edges.iter().map(|&p| at(&a, ow, p).abs_diff(at(&b, 2 * ow, crop(p)))).collect();
+ let mean = diffs.iter().map(|&d| d as f32).sum::<f32>() / diffs.len() as f32;
+ let max = diffs.iter().copied().max().unwrap_or(0);
+ let dof = edges.iter().map(|&p| at(&a, ow, p).abs_diff(at(&net, ow, p))).max().unwrap_or(0);
+ // La pyramide est bien liee : elle grise les rayures sans les assombrir.
+ let level = |rgba: &[u8]| edges.iter().map(|&p| at(rgba, ow, p) as f32).sum::<f32>() / edges.len() as f32;
+ let (lit, flat) = (level(&a), level(&net));
+ eprintln!("t={t} : bord de la sortie, ecart moyen {mean:.2}, max {max} (profondeur de champ : {dof}, niveau {lit:.1} / {flat:.1})");
+ assert!(dof > 60, "t={t} : la profondeur de champ n'agit pas au bord, le test ne prouve rien");
+ assert!((lit - flat).abs() < 4.0, "t={t} : la profondeur de champ assombrit le bord ({lit:.1} / {flat:.1})");
+ assert!(mean < 1.0 && max <= 16, "t={t} : le bord perd la profondeur de champ ({mean:.2}, {max})");
+ }
+ }
+
/// Un degrade de fond est opaque et montre chacun de ses stops, meme quand le premier est a
/// 0. `gradient_layer` range la position du premier stop dans `color.a` ; la queue commune
/// du WGSL la prenait pour une opacite, et le fond disparaissait sous la couleur de clear
diff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rs
index b9fddb818..b00a288ee 100644
--- a/crates/compositor/src/compositor_macos.rs
+++ b/crates/compositor/src/compositor_macos.rs
@@ -1373,7 +1373,7 @@ impl Compositor {
}
/// Écran incliné (mode 8) : le calque partagé (`frame_geometry::tilted_screen_cb`), avec la
- /// pyramide de profondeur de champ en texture(2).
+ /// pyramide de profondeur de champ en texture(5).
#[allow(clippy::too_many_arguments)]
unsafe fn draw_tilted_screen(
&self,
@@ -1396,9 +1396,9 @@ impl Compositor {
dof_pyramid: Option<&metal::Texture>,
) {
let render_px = [self.render_w as f32, self.render_h as f32];
- // texture(2) EXPLICITE : `draw_video` ne lie que 0/1, et le slot 2 garde sinon ce que
- // le draw précédent y a laissé. `None` quand l'effet est coupé : `k = 0`, rien n'y est lu.
- enc.set_fragment_texture(2, dof_pyramid.map(|t| &**t));
+ // La pyramide en texture(5), que `draw_video` ne lie pas. `None` quand l'effet est
+ // coupé : `k = 0`, rien n'y est lu.
+ enc.set_fragment_texture(5, dof_pyramid.map(|t| &**t));
// La pyramide liée décide seule si la profondeur de champ tourne.
let cb = crate::frame_geometry::tilted_screen_cb(
quad,
@@ -2391,8 +2391,11 @@ impl Compositor {
if trail {
enc.end_encoding();
enc = self.begin_pass(cmd_buf, &self.rt, None, &self.pipeline_main)?;
+ // texture(2) = l'écran cadré isolé ; texture(5) = la pyramide, avec laquelle le repli
+ // relit le métrage hors de la sortie comme le mode 8 l'a dessiné.
enc.set_fragment_texture(2, Some(&self.trail));
- self.draw_video(enc, &g.screen_trail_cb([rw, rh]), &sy, &suv);
+ enc.set_fragment_texture(5, dof_pyramid.as_ref().map(|t| &**t));
+ self.draw_video(enc, &g.screen_trail_cb([rw, rh], dof_pyramid.is_some()), &sy, &suv);
}
enc.end_encoding();
@@ -3584,7 +3587,7 @@ mod tests {
//
// Le seul golden de l'effet qui tourne en CI : celui de Windows est opt-in (source vidéo),
// celui de Linux aussi (`OPENSCREEN_LINUX_COMPOSE`). C'est aussi le premier vrai passage de
- // `fill_dof_pyramid`, de `generate_mipmaps` et du `texture(2)` du mode 8. Le piège qu'il
+ // `fill_dof_pyramid`, de `generate_mipmaps` et du `texture(5)` du mode 8. Le piège qu'il
// garde : un `level(lod)` qui retomberait au niveau 0 laisserait macOS net là où Windows
// floute.
// -----------------------------------------------------------------------
diff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rs
index 6a50ff781..59431e383 100644
--- a/crates/compositor/src/compositor_windows.rs
+++ b/crates/compositor/src/compositor_windows.rs
@@ -74,9 +74,10 @@ struct WebcamMask {
height: u32,
}
-/// Pyramide de la profondeur de champ (mode 8) : la vidéo en RGBA8 à demi-résolution de la
-/// texture DÉCODEUR, avec sa chaîne de mips. Dimensionnée sur la texture décodeur et remplie en
-/// UV plein (0..1) : ses UV sont ceux de t0/t1, et le calcul d'UV du mode 8 ne change pas.
+/// Pyramide de la profondeur de champ (modes 8 et 18, en t5) : la vidéo en RGBA8 à
+/// demi-résolution de la texture DÉCODEUR, avec sa chaîne de mips. Dimensionnée sur la texture
+/// décodeur et remplie en UV plein (0..1) : ses UV sont ceux de t0/t1, et le calcul d'UV du
+/// mode 8 ne change pas.
struct DofPyramid {
rtv: ID3D11RenderTargetView,
srv: ID3D11ShaderResourceView,
@@ -978,9 +979,9 @@ impl Compositor {
let pyr = self.dof_pyramid.borrow();
let pyr = pyr.as_ref().expect("pyramide allouée ci-dessus");
self.bind_compose_state();
- // Délie t2 : la pyramide y est peut-être encore liée depuis le mode 8 précédent, et une
- // ressource liée en lecture ET en écriture est retirée d'office par le runtime.
- self.ctx.PSSetShaderResources(2, Some(&[None]));
+ // Délie t5 : la pyramide y est peut-être encore liée depuis le mode 8 ou 18 précédent, et
+ // une ressource liée en lecture ET en écriture est retirée d'office par le runtime.
+ self.ctx.PSSetShaderResources(5, Some(&[None]));
self.ctx.OMSetRenderTargets(Some(&[Some(pyr.rtv.clone())]), None);
self.ctx.ClearRenderTargetView(&pyr.rtv, &[0.0, 0.0, 0.0, 0.0]);
self.ctx.RSSetViewports(Some(&[D3D11_VIEWPORT {
@@ -2073,10 +2074,9 @@ impl Compositor {
// rendus dans le repère DU PLAN : sans eux le plan a des arêtes de couteau qui
// tranchent le contenu en pleine phrase, et l'œil lit une découpe là où il devrait
// lire une inclinaison.
- // t2 EXPLICITE : `draw_video` ne lie que t0/t1, et t2 garde sinon ce que le draw
- // précédent y a laissé (un wallpaper, un sprite). `None` quand l'effet est coupé :
- // `k = 0`, le shader n'y lit rien.
- self.ctx.PSSetShaderResources(2, Some(&[dof_srv.clone()]));
+ // La pyramide de profondeur de champ en t5, que `draw_video` ne lie pas. `None` quand
+ // l'effet est coupé : `k = 0`, le shader n'y lit rien.
+ self.ctx.PSSetShaderResources(5, Some(&[dof_srv.clone()]));
self.draw_video(
&crate::frame_geometry::tilted_screen_cb(
&quad,
@@ -2094,7 +2094,7 @@ impl Compositor {
&sy,
&suv,
);
- self.ctx.PSSetShaderResources(2, Some(&[None]));
+ self.ctx.PSSetShaderResources(5, Some(&[None]));
} else {
// Sous le masque d'un layout en bloc, rogné au slot (`FrameGeometry::mask_flat_screen`).
let (dst, src, quad_px, radius_px) = g.mask_flat_screen(
@@ -2129,9 +2129,13 @@ impl Compositor {
}
if trail {
self.ctx.OMSetRenderTargets(Some(&[Some(self.rtv.clone())]), None);
+ // t2 = l'écran cadré isolé ; t5 = la pyramide, avec laquelle le repli relit le
+ // métrage hors de la sortie comme le mode 8 l'a dessiné.
self.ctx.PSSetShaderResources(2, Some(&[Some(self.trail_srv.clone())]));
- self.draw_video(&g.screen_trail_cb(render_px), &sy, &suv);
+ self.ctx.PSSetShaderResources(5, Some(&[dof_srv.clone()]));
+ self.draw_video(&g.screen_trail_cb(render_px, dof), &sy, &suv);
self.ctx.PSSetShaderResources(2, Some(&[None]));
+ self.ctx.PSSetShaderResources(5, Some(&[None]));
}
// --- curseur custom : suit le mapping src/dst (zoom+layout), click bounce,
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rs
index cad782a6f..aa3d9b5a4 100644
--- a/crates/compositor/src/frame_geometry.rs
+++ b/crates/compositor/src/frame_geometry.rs
@@ -2099,14 +2099,18 @@ impl FrameGeometry {
/// 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 {
+ ///
+ /// Le métrage relu hors de la sortie l'est comme le mode 8 l'a dessiné : incliné, `trail_mb`
+ /// porte SA profondeur de champ (son `mb` ; `dof` = `depth_of_field_on`, vrai quand la
+ /// pyramide est liée) et `color.xy` sa lampe. Nuls à plat : le repli relit le métrage net.
+ pub fn screen_trail_cb(&self, render_px: [f32; 2], dof: bool) -> LayerCB {
+ let s_px = [self.s_dst[2] * render_px[0], self.s_dst[3] * render_px[1]];
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]],
+ quad_px: s_px,
radius_px: self.s_radius,
mode: 18.0,
- color: [1.0, 1.0, 1.0, 1.0],
fx: self.s_dst,
dst_prev: self.s_dst_prev,
mb: [self.mb_taps, self.mb_amount, 0.0, 0.0],
@@ -2120,14 +2124,19 @@ impl FrameGeometry {
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);
+ // Le calque que le mode 8 dessine pour ce plan : sa profondeur de champ et sa lampe ne
+ // dépendent ni du rayon, ni du chrome, ni d'un masque.
+ let plane = tilted_screen_cb(&quad, s_px, c, self.cut, self.focus_plane, 0.0, 0.0, dof, render_px, None, None);
LayerCB {
- quad_px: flat.quad_px.map(|v| v * quad.scale),
+ quad_px: s_px.map(|v| v * quad.scale),
radius_px: self.s_radius * quad.scale,
+ color: [plane.color[0], plane.color[1], 0.0, 0.0],
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()],
+ trail_mb: plane.mb,
..flat
}
}
@@ -4667,9 +4676,11 @@ mod tests {
g.s_dst_prev[2] *= 0.9;
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);
+ let cb = g.screen_trail_cb(RENDER, true);
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");
+ // À plat, ni profondeur de champ ni lampe : le repli relit le métrage net.
+ assert_eq!((cb.trail_mb, cb.color), ([0.0; 4], [0.0; 4]), "{frame}: repli net");
g.mb_amount = 0.0;
assert!(!g.screen_trail(RENDER), "{frame}: flou coupé");
g.mb_amount = 1.0;
@@ -4710,7 +4721,7 @@ mod tests {
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);
+ let cb = g.screen_trail_cb(RENDER, true);
// 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 };
@@ -4725,6 +4736,12 @@ mod tests {
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);
+ // Et il relit le métrage comme le mode 8 l'a dessiné : même profondeur de champ
+ // (son `mb`), même lampe (son `color.xy`).
+ let mode8 = tilted_screen_cb(&quad, s_px, c, g.cut, g.focus_plane, g.s_radius, 0.0, true, RENDER, None, None);
+ assert!(mode8.mb[3] > 0.0, "{case}: la profondeur de champ doit tourner");
+ assert_eq!(cb.trail_mb, mode8.mb, "{case}: profondeur de champ du repli");
+ assert_eq!(cb.color, [mode8.color[0], mode8.color[1], 0.0, 0.0], "{case}: lampe du repli");
// Sous un masque de bloc, la case ne bouge pas : retour au flou par pixel.
let mut masked = g;
diff --git a/crates/compositor/src/shaders.hlsl b/crates/compositor/src/shaders.hlsl
index a14c0acb0..30fbf1bd5 100644
--- a/crates/compositor/src/shaders.hlsl
+++ b/crates/compositor/src/shaders.hlsl
@@ -15,7 +15,7 @@ cbuffer Layer : register(b0)
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
+ float4 trail_mb; // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; mode 18 incliné : le `mb` du mode 8 (profondeur de champ), et `color.xy` sa lampe ; 0 ailleurs
};
// Mode 15 (curseur modélisé) : le détail des emplacements est dans `frame_geometry.rs`, en tête
// de la section « Curseur modélisé » (`cursor_model_cb`). Mode 17 (appareil modelé) : en tête de
@@ -44,7 +44,7 @@ VSOut vs_main(uint vid : SV_VertexID)
Texture2D<float> texY : register(t0);
Texture2D<float2> texUV : register(t1);
-Texture2D<float4> texImg : register(t2); // wallpaper image RGBA (fond, mode 6) ; mode 8 : pyramide de flou
+Texture2D<float4> texImg : register(t2); // wallpaper image RGBA (fond, mode 6) ; mode 18 : l'écran cadré isolé
// Masque de segmentation du sujet, 0 = fond, 1 = sujet. Produit par `segmentation.rs` a la
// resolution du modele (256x144) ; l'upscale vers la resolution webcam est fait par le sampler
// lineaire, ce qui est exactement le filtrage qu'on veut sur un masque.
@@ -52,6 +52,9 @@ Texture2D<float> texMask : register(t3);
// Champ de distance signé du sprite de curseur (mode 15 seulement), R16F, cf. `cursor_sdf.rs`.
// Le sprite lui-même est en t2 (texImg), comme aux modes 7 et 13.
Texture2D<float> texSdf : register(t4);
+// Pyramide de profondeur de champ (`tilted_sample`), lue par le mode 8 et par le repli du mode 18,
+// qui garde t2 pour son rendu isolé : d'où un emplacement à elle.
+Texture2D<float4> texDof : register(t5);
SamplerState samp : register(s0);
// Plafond de la profondeur de champ du mode 8, en niveau de la pyramide demi-résolution (1.5 =
@@ -207,6 +210,12 @@ float3 quad_st_for_root(float t, float2 e, float2 f, float2 g, float2 h)
// par le mode 8 (écran incliné) et le mode 13 (curseur posé sur ce même écran). Les deux doivent
// résoudre exactement la même équation, sinon le curseur glisse par rapport au contenu — d'où
// une seule implémentation plutôt que deux copies.
+//
+// `ok` = −1 quand `P` n'a AUCUN antécédent : au-delà du pli du warp bilinéaire, qu'aucun point
+// du plan prolongé n'atteint. (s, t) n'y veut rien dire. Ce n'est pas l'origine (0, 0), qui est
+// un vrai point du plan : le mode 18 le renvoyait sur le coin haut-gauche de l'écran, et le fond
+// loin de l'écran prenait la couleur de ce coin. Les appelants qui testent `ok < 0.5` écartent
+// ce pixel comme un pixel hors du quad ; ceux qui prolongent (s, t) hors du quad testent `ok < -0.5`.
float3 quad_inverse_bilinear(float2 P, float2 c00, float2 c10, float2 c11, float2 c01)
{
float2 e = c10 - c00;
@@ -225,11 +234,12 @@ float3 quad_inverse_bilinear(float2 P, float2 c00, float2 c10, float2 c11, float
// du quad était rejetée, ce qui se voyait comme un écran incliné tranché net.
if (abs(k2) < 1e-5 * abs(k1))
{
- float t = (abs(k1) < 1e-6) ? 0.0 : -k0 / k1;
- return quad_st_for_root(t, e, f, g, h);
+ // k1 nul aussi : l'équation ne fixe plus `t`, aucun point à rendre.
+ if (abs(k1) < 1e-6) return float3(0.0, 0.0, -1.0);
+ return quad_st_for_root(-k0 / k1, e, f, g, h);
}
float disc = k1 * k1 - 4.0 * k2 * k0;
- if (disc < 0.0) return float3(0.0, 0.0, 0.0);
+ if (disc < 0.0) return float3(0.0, 0.0, -1.0);
// Forme stable : `q` n'oppose jamais deux quantités voisines, et les deux racines
// s'en déduisent exactement. `sign()` est évité parce qu'il vaut 0 en 0, ce qui
// annulerait `q` là où la formule reste parfaitement définie.
@@ -269,6 +279,7 @@ float3 quad_inverse_projective(float2 P, float2 c00, float2 c10, float2 c11, flo
// Le warp inverse d'un calque posé sur le plan : projectif sous la caméra réelle ou un appareil
// (`projective` = 1, cf. `TiltedQuad::warp_flag`), bilinéaire sous un angle fixe, inchangé.
+// `ok` : 1 dans le quad, 0 dehors, −1 sans antécédent (`quad_inverse_bilinear`).
float3 quad_inverse(float2 P, float2 c00, float2 c10, float2 c11, float2 c01, float projective)
{
if (projective > 0.5)
@@ -300,7 +311,7 @@ float2 quad_forward(float2 st, float2 c00, float2 c10, float2 c11, float2 c01, f
}
// 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,
+// profondeur de champ (t5) au-delà d'un demi-texel de cercle de confusion `coc`. Sous ce seuil,
// l'échantillon net d'avant, à l'octet.
float3 tilted_sample(float2 uv, float coc)
{
@@ -308,7 +319,7 @@ float3 tilted_sample(float2 uv, float coc)
if (coc > 0.5)
{
float lod = clamp(log2(coc) - 1.0, 0.0, DOF_MAX_LOD);
- float3 far_rgb = texImg.SampleLevel(samp, uv, lod).rgb;
+ float3 far_rgb = texDof.SampleLevel(samp, uv, lod).rgb;
rgb = lerp(rgb, far_rgb, saturate((coc - 0.5) / 1.5));
}
return rgb;
@@ -2153,9 +2164,12 @@ float4 ps_main(VSOut i) : SV_Target
// (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
+ // plan vers le rendu courant) ; un pixel que le plan prolongé n'atteint pas (aller sans
+ // solution) n'a pas de tap. 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é.
+ // relit le métrage (`src` = la coupe) comme le mode 8 l'a dessiné, avec sa profondeur de champ
+ // (`trail_mb` = son `mb`, pyramide en t5) et sa lampe (`color.xy`), nulles à plat ; ailleurs
+ // (un bout de cadre hors champ), le tap est écarté.
if (mode > 17.5)
{
int taps = (int) mb.x;
@@ -2171,7 +2185,9 @@ float4 ps_main(VSOut i) : SV_Target
{
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;
+ float3 r = quad_inverse(i.pout, ta.xy, ta.zw, tb.xy, tb.zw, mb.w);
+ if (r.z < -0.5) continue;
+ f = r.xy;
q = quad_forward(f, fx.xy, fx.zw, src_prev.xy, src_prev.zw, mb.w);
}
else
@@ -2187,7 +2203,10 @@ float4 ps_main(VSOut i) : SV_Target
}
else if (sd_round_rect(f * quad_px - quad_px * 0.5, quad_px * 0.5, radius_px) < -2.0)
{
- acc += float4(sample_yuv(lerp(src.xy, src.zw, f)), 1.0);
+ float z = (f.x - 0.5) * trail_mb.x + (f.y - 0.5) * trail_mb.y;
+ float3 rgb = tilted_sample(lerp(src.xy, src.zw, f), trail_mb.w * abs(z - trail_mb.z));
+ rgb = saturate(rgb * (1.0 + color.x * (f.x - 0.5) + color.y * (f.y - 0.5)));
+ acc += float4(rgb, 1.0);
n += 1.0;
}
}
@@ -2299,7 +2318,7 @@ float4 ps_main(VSOut i) : SV_Target
// mb = [gx, gy, z_focus, k] : profondeur du point r du plan = (r.x - 0.5)*gx + (r.y - 0.5)*gy
// en px, positive vers la caméra ; z_focus = celle du focus du zoom (`TiltedQuad::depth_mb`) ;
// k = texels source de flou par px d'écart de profondeur (0 = profondeur de champ coupée).
- // t2 (texImg) = pyramide demi-résolution de la vidéo, 5 niveaux, mêmes UV que t0/t1 ; liée
+ // t5 (texDof) = pyramide demi-résolution de la vidéo, 5 niveaux, mêmes UV que t0/t1 ; liée
// explicitement à chaque draw du mode 8 (`draw_video` ne lie que t0/t1).
// trail_a/trail_b = coins du plan à la frame précédente, trail_mb = [taps, force] : son flou
// de mouvement (`FrameGeometry::tilt_trail`).
@@ -2481,7 +2500,7 @@ float4 ps_main(VSOut i) : SV_Target
// Profondeur de champ : cercle de confusion en texels source, nul au focus du zoom.
// Sous un demi-texel, l'échantillon net d'avant, à l'octet : le texte net ne passe
// jamais par le RGBA de la pyramide, et `k = 0` (réglage coupé) ne quitte jamais cette
- // voie. Au-delà, fondu vers la pyramide demi-résolution (t2) au niveau `log2(coc) - 1`
+ // voie. Au-delà, fondu vers la pyramide demi-résolution (t5) au niveau `log2(coc) - 1`
// (son niveau 0 est déjà une moyenne 2x2), plafonné à DOF_MAX_LOD : au niveau 2, un
// bloc 4x4 soude les jambages d'un « m » en 1080p (`tilted_sample`).
float2 rs = saturate(float2(r.x, r.y));
@@ -2491,7 +2510,8 @@ 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). Le
+ // plan d'avant, le warp prolongé donne encore le bon point (sa racine proche) ; sans
+ // solution, il n'y a pas de point d'avant, et l'échantillon reste net. 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;
@@ -2499,7 +2519,7 @@ float4 ps_main(VSOut i) : SV_Target
{
float3 rp = quad_inverse(i.local, trail_a.xy, trail_a.zw, trail_b.xy, trail_b.zw, dst_prev.w);
float2 duv = (r.xy - rp.xy) * (src.zw - src.xy) * saturate(trail_mb.y);
- if (dot(duv, duv) >= 1e-9)
+ if (rp.z > -0.5 && dot(duv, duv) >= 1e-9)
{
float3 acc = 0.0;
[loop] for (int k = 0; k < 16; k++)
diff --git a/crates/compositor/src/shaders.metal b/crates/compositor/src/shaders.metal
index ef377d81e..6c019c3ec 100644
--- a/crates/compositor/src/shaders.metal
+++ b/crates/compositor/src/shaders.metal
@@ -114,7 +114,8 @@ constant float DOF_MAX_LOD = 1.5;
// Slots de texture, tenus par les paramètres des entry points :
// ps_main : 0 = texY (Y, R8), 1 = texUV (CbCr, RG8), 2 = texImg (RGBA), 3 = texMask (R8),
-// 4 = texSdf (champ du sprite de curseur, R16F, mode 15)
+// 4 = texSdf (champ du sprite de curseur, R16F, mode 15),
+// 5 = texDof (pyramide de profondeur de champ, RGBA, modes 8 et 18)
// ps_fs_* : 0 = rgbTex (RGBA)
// =================================================================================
@@ -266,6 +267,8 @@ inline float3 quad_st_for_root(float t, float2 e, float2 f, float2 g, float2 h)
}
// (s, t, ok) du point `P` dans le quad c00->c10->c11->c01 : le warp bilinéaire INVERSE.
+// `ok` = −1 quand `P` n'a AUCUN antécédent (au-delà du pli du warp) : (s, t) n'y veut rien dire,
+// et ce n'est pas l'origine du plan (cf. HLSL, qui fait foi).
inline float3 quad_inverse_bilinear(float2 P, float2 c00, float2 c10, float2 c11, float2 c01)
{
float2 e = c10 - c00;
@@ -277,11 +280,12 @@ inline float3 quad_inverse_bilinear(float2 P, float2 c00, float2 c10, float2 c11
float k0 = h.x * e.y - h.y * e.x;
if (abs(k2) < 1e-5 * abs(k1))
{
- float t = (abs(k1) < 1e-6) ? 0.0 : -k0 / k1;
- return quad_st_for_root(t, e, f, g, h);
+ // k1 nul aussi : l'équation ne fixe plus `t`, aucun point à rendre.
+ if (abs(k1) < 1e-6) return float3(0.0, 0.0, -1.0);
+ return quad_st_for_root(-k0 / k1, e, f, g, h);
}
float disc = k1 * k1 - 4.0 * k2 * k0;
- if (disc < 0.0) return float3(0.0, 0.0, 0.0);
+ if (disc < 0.0) return float3(0.0, 0.0, -1.0);
float q = -0.5 * (k1 + (k1 >= 0.0 ? 1.0 : -1.0) * sqrt(disc));
float3 r0 = quad_st_for_root(q / k2, e, f, g, h);
float3 r1 = quad_st_for_root(abs(q) > 0.0 ? k0 / q : q / k2, e, f, g, h);
@@ -316,6 +320,7 @@ inline float3 quad_inverse_projective(float2 P, float2 c00, float2 c10, float2 c
// Warp inverse d'un calque posé sur le plan : projectif sous la caméra réelle ou un appareil
// (`projective` = 1), bilinéaire sous un angle fixe, inchangé.
+// `ok` : 1 dans le quad, 0 dehors, −1 sans antécédent (`quad_inverse_bilinear`).
inline float3 quad_inverse(float2 P, float2 c00, float2 c10, float2 c11, float2 c01, float projective)
{
if (projective > 0.5)
@@ -346,18 +351,18 @@ inline float2 quad_forward(float2 st, float2 c00, float2 c10, float2 c11, float2
}
// 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
+// profondeur de champ (texture(5)) 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).
inline float3 tilted_sample(float2 uv, float coc,
texture2d<float, access::sample> texY,
texture2d<float, access::sample> texUV,
- texture2d<float, access::sample> texImg)
+ texture2d<float, access::sample> texDof)
{
float3 rgb = sample_yuv(uv, texY, texUV);
if (coc > 0.5)
{
float lod = clamp(log2(coc) - 1.0, 0.0, DOF_MAX_LOD);
- float3 far_rgb = texImg.sample(samp, uv, level(lod)).rgb;
+ float3 far_rgb = texDof.sample(samp, uv, level(lod)).rgb;
rgb = mix(rgb, far_rgb, clamp((coc - 0.5) / 1.5, 0.0, 1.0));
}
return rgb;
@@ -2016,15 +2021,21 @@ fragment float4 ps_main(VSOut i [[stage_in]],
// Champ de distance du sprite de curseur (mode 15 seulement), R16F, cf.
// `cursor_sdf.rs`. Le sprite lui-même est en texture(2), comme aux
// modes 7 et 13.
- texture2d<float, access::sample> texSdf [[texture(4)]])
+ texture2d<float, access::sample> texSdf [[texture(4)]],
+ // Pyramide de profondeur de champ (`tilted_sample`), lue par le mode 8 et
+ // par le repli du mode 18, qui garde texture(2) pour son rendu isolé.
+ texture2d<float, access::sample> texDof [[texture(5)]])
{
// 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. À 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.
+ // `fx`/`src_prev`, et le warp du plan (`mb.w`, celui du mode 8) fait l'aller et le retour ;
+ // un pixel que le plan prolongé n'atteint pas (aller sans solution) n'a pas de tap.
// 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é.
+ // `radius_px`, 2 px en retrait) on relit le métrage (`src` = la coupe) comme le mode 8 l'a
+ // dessiné, avec sa profondeur de champ (`trail_mb` = son `mb`, pyramide en texture(5)) et sa
+ // lampe (`color.xy`), nulles à plat ; ailleurs le tap est écarté.
if (layer.mode > 17.5)
{
int taps = int(layer.mb.x);
@@ -2040,7 +2051,9 @@ fragment float4 ps_main(VSOut i [[stage_in]],
{
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;
+ float3 r = quad_inverse(i.pout, ta.xy, ta.zw, tb.xy, tb.zw, layer.mb.w);
+ if (r.z < -0.5) continue;
+ f = r.xy;
q = quad_forward(f, layer.fx.xy, layer.fx.zw,
layer.src_prev.xy, layer.src_prev.zw, layer.mb.w);
}
@@ -2058,7 +2071,11 @@ fragment float4 ps_main(VSOut i [[stage_in]],
else if (sd_round_rect(f * layer.quad_px - layer.quad_px * 0.5, layer.quad_px * 0.5,
layer.radius_px) < -2.0)
{
- acc += float4(sample_yuv(mix(layer.src.xy, layer.src.zw, f), texY, texUV), 1.0);
+ float z = (f.x - 0.5) * layer.trail_mb.x + (f.y - 0.5) * layer.trail_mb.y;
+ float3 rgb = tilted_sample(mix(layer.src.xy, layer.src.zw, f),
+ layer.trail_mb.w * abs(z - layer.trail_mb.z), texY, texUV, texDof);
+ rgb = clamp(rgb * (1.0 + layer.color.x * (f.x - 0.5) + layer.color.y * (f.y - 0.5)), 0.0, 1.0);
+ acc += float4(rgb, 1.0);
n += 1.0;
}
}
@@ -2202,7 +2219,7 @@ fragment float4 ps_main(VSOut i [[stage_in]],
// mb = [gx, gy, z_focus, k] : profondeur du point r du plan = (r.x - 0.5)*gx + (r.y - 0.5)*gy
// en px, positive vers la caméra ; z_focus = celle du focus du zoom (`TiltedQuad::depth_mb`) ;
// k = texels source de flou par px d'écart de profondeur (0 = profondeur de champ coupée).
- // texture(2) (texImg) = pyramide demi-résolution de la vidéo, 5 niveaux, mêmes UV que
+ // texture(5) (texDof) = pyramide demi-résolution de la vidéo, 5 niveaux, mêmes UV que
// texture(0/1) ; liée explicitement à chaque draw du mode 8. Cf. commentaires HLSL.
if (layer.mode > 7.5 && layer.mode < 8.5)
{
@@ -2243,7 +2260,7 @@ fragment float4 ps_main(VSOut i [[stage_in]],
float2 rs = clamp(float2(r.x, r.y), 0.0, 1.0);
float z = (rs.x - 0.5) * layer.mb.x + (rs.y - 0.5) * layer.mb.y;
float coc = layer.mb.w * abs(z - layer.mb.z);
- float3 rgb = tilted_sample(uv, coc, texY, texUV, texImg);
+ float3 rgb = tilted_sample(uv, coc, texY, texUV, texDof);
// 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. Le
@@ -2255,14 +2272,15 @@ fragment float4 ps_main(VSOut i [[stage_in]],
layer.trail_b.xy, layer.trail_b.zw, layer.dst_prev.w);
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)
+ // Sans antécédent sur le plan d'avant, pas de point d'avant : l'échantillon reste net.
+ if (rp.z > -0.5 && dot(duv, duv) >= 1e-9)
{
float3 acc = float3(0.0);
for (int k = 0; k < 16; k++)
{
if (k >= taps) break;
float t = float(k) / float(taps - 1);
- acc += tilted_sample(uv - duv * (1.0 - t), coc, texY, texUV, texImg);
+ acc += tilted_sample(uv - duv * (1.0 - t), coc, texY, texUV, texDof);
}
rgb = acc / float(taps);
}
diff --git a/crates/compositor/src/vk_shaders/layer.wgsl b/crates/compositor/src/vk_shaders/layer.wgsl
index 4549c4740..2eb46a9b3 100644
--- a/crates/compositor/src/vk_shaders/layer.wgsl
+++ b/crates/compositor/src/vk_shaders/layer.wgsl
@@ -30,7 +30,7 @@ struct Layer {
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
+ trail_mb: vec4<f32>, // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; mode 18 incline : le `mb` du mode 8 (profondeur de champ), et `color.xy` sa lampe ; 0 ailleurs
}
@group(0) @binding(0) var<uniform> layer: Layer;
@@ -39,9 +39,11 @@ struct Layer {
@group(0) @binding(3) var samp: sampler;
// Masque de segmentation du sujet webcam, R8. Une vue 1x1 est liee quand aucun masque
// n'existe : la branche n'est de toute facon prise que si layer.fx.z > 0.5.
-// Mode 8 : ce binding porte a la place la pyramide RGBA de profondeur de champ (jamais le
-// binding 1, qui porte la luma).
+// Mode 18 : ce binding porte a la place le rendu isole de l'ecran cadre.
@group(0) @binding(4) var texMask: texture_2d<f32>;
+// Pyramide RGBA de profondeur de champ (`tilted_sample`), lue par le mode 8 et par le repli du
+// mode 18, qui garde le binding 4 pour son rendu isole : d'ou un binding a elle. Vue 1x1 ailleurs.
+@group(0) @binding(6) var texDof: texture_2d<f32>;
// Plafond de la profondeur de champ du mode 8, en niveau de la pyramide demi-resolution.
// Meme valeur que `DOF_MAX_LOD` du HLSL.
@@ -108,9 +110,11 @@ fn sample_yuv_level(uv: vec2<f32>) -> vec3<f32> {
// 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.
+// l'aller et le retour ; un pixel que le plan prolonge n'atteint pas (aller sans solution) n'a pas
+// de tap. 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) comme le mode 8 l'a dessine,
+// avec sa profondeur de champ (`trail_mb` = son `mb`, pyramide en binding 6) et sa lampe
+// (`color.xy`), nulles a plat ; ailleurs le tap est ecarte.
fn screen_trail(pout: vec2<f32>) -> vec4<f32> {
let taps = i32(layer.mb.x);
var acc = vec4<f32>(0.0);
@@ -123,7 +127,9 @@ fn screen_trail(pout: vec2<f32>) -> vec4<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;
+ let r = quad_inverse(pout, ta.xy, ta.zw, tb.xy, tb.zw, layer.mb.w);
+ if r.z < -0.5 { continue; }
+ f = r.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);
@@ -139,7 +145,11 @@ fn screen_trail(pout: vec2<f32>) -> vec4<f32> {
} else {
let hs = layer.quad_px * 0.5;
if sd_round_rect(f * layer.quad_px - hs, hs, layer.radius_px) < -2.0 {
- acc = acc + vec4<f32>(sample_yuv_level(mix(layer.src.xy, layer.src.zw, f)), 1.0);
+ let z = (f.x - 0.5) * layer.trail_mb.x + (f.y - 0.5) * layer.trail_mb.y;
+ let rgb = tilted_sample(mix(layer.src.xy, layer.src.zw, f),
+ layer.trail_mb.w * abs(z - layer.trail_mb.z));
+ let shade = 1.0 + layer.color.x * (f.x - 0.5) + layer.color.y * (f.y - 0.5);
+ acc = acc + vec4<f32>(clamp(rgb * shade, vec3<f32>(0.0), vec3<f32>(1.0)), 1.0);
n = n + 1.0;
}
}
@@ -285,6 +295,8 @@ fn quad_st_for_root(t: f32, e: vec2<f32>, f: vec2<f32>, g: vec2<f32>, h: vec2<f3
}
// (s, t, ok) du point `P` dans le quad c00->c10->c11->c01 : le warp bilineaire INVERSE.
+// `ok` = -1 quand `P` n'a AUCUN antecedent (au-dela du pli du warp) : (s, t) n'y veut rien dire,
+// et ce n'est pas l'origine du plan (cf. HLSL, qui fait foi).
fn quad_inverse_bilinear(P: vec2<f32>, c00: vec2<f32>, c10: vec2<f32>, c11: vec2<f32>, c01: vec2<f32>) -> vec3<f32> {
let e = c10 - c00;
let f = c01 - c00;
@@ -296,15 +308,15 @@ fn quad_inverse_bilinear(P: vec2<f32>, c00: vec2<f32>, c10: vec2<f32>, c11: vec2
// Quad quasi affine (rotation Y pure, p.ex.) : le terme quadratique s'evanouit
// et resoudre la quadratique diviserait par ~0.
if abs(k2) < 1e-5 * abs(k1) {
- var t = 0.0;
- if abs(k1) >= 1e-6 {
- t = -k0 / k1;
+ // k1 nul aussi : l'equation ne fixe plus `t`, aucun point a rendre.
+ if abs(k1) < 1e-6 {
+ return vec3<f32>(0.0, 0.0, -1.0);
}
- return quad_st_for_root(t, e, f, g, h);
+ return quad_st_for_root(-k0 / k1, e, f, g, h);
}
let disc = k1 * k1 - 4.0 * k2 * k0;
if disc < 0.0 {
- return vec3<f32>(0.0, 0.0, 0.0);
+ return vec3<f32>(0.0, 0.0, -1.0);
}
// Forme stable de la quadratique : additionner deux termes de meme signe evite
// l'annulation catastrophique que `(-k1 +- sqrt(disc)) / (2 k2)` produit quand
@@ -357,6 +369,7 @@ fn quad_inverse_projective(P: vec2<f32>, c00: vec2<f32>, c10: vec2<f32>, c11: ve
// Warp inverse d'un calque pose sur le plan : projectif sous la camera reelle ou un appareil
// (`projective` = 1), bilineaire sous un angle fixe, inchange.
+// `ok` : 1 dans le quad, 0 dehors, -1 sans antecedent (`quad_inverse_bilinear`).
fn quad_inverse(P: vec2<f32>, c00: vec2<f32>, c10: vec2<f32>, c11: vec2<f32>, c01: vec2<f32>, projective: f32) -> vec3<f32> {
if projective > 0.5 {
return quad_inverse_projective(P, c00, c10, c11, c01);
@@ -383,14 +396,15 @@ fn quad_forward(st: vec2<f32>, c00: vec2<f32>, c10: vec2<f32>, c11: vec2<f32>, c
}
// 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
-// `tilted_sample` (HLSL). LOD explicite : pas de derivees dans cette branche.
+// profondeur de champ (binding 6) au-dela d'un demi-texel de cercle de confusion `coc`. Sous ce
+// seuil, l'echantillon net d'avant, a l'octet. Miroir de `tilted_sample` (HLSL). LOD explicite
+// partout : les plans video n'ont qu'un niveau, donc c'est le meme echantillon, et le repli du
+// mode 18 l'appelle hors du flot uniforme.
fn tilted_sample(uv: vec2<f32>, coc: f32) -> vec3<f32> {
- var rgb = sample_yuv(uv);
+ var rgb = sample_yuv_level(uv);
if coc > 0.5 {
let lod = clamp(log2(coc) - 1.0, 0.0, DOF_MAX_LOD);
- let far_rgb = textureSampleLevel(texMask, samp, uv, lod).rgb;
+ let far_rgb = textureSampleLevel(texDof, samp, uv, lod).rgb;
rgb = mix(rgb, far_rgb, clamp((coc - 0.5) / 1.5, 0.0, 1.0));
}
return rgb;
@@ -2100,9 +2114,9 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
let tilt_a = (1.0 - smoothstep(0.0, 1.5, d))
* slot_alpha(i.local, layer.quad_px, layer.color.w);
// Profondeur de champ (cf. HLSL) : net sous un demi-texel de flou, l'echantillon
- // d'avant a l'octet ; au-dela, fondu vers la pyramide demi-resolution liee en binding 4
- // (a la place du masque webcam, que ce mode ne lit pas), au niveau `log2(coc) - 1`,
- // plafonne. LOD explicite : pas de derivees dans cette branche (`tilted_sample`).
+ // d'avant a l'octet ; au-dela, fondu vers la pyramide demi-resolution liee en binding 6,
+ // au niveau `log2(coc) - 1`, plafonne. LOD explicite : pas de derivees dans cette branche
+ // (`tilted_sample`).
let rs = clamp(vec2<f32>(r.x, r.y), vec2<f32>(0.0), vec2<f32>(1.0));
let z = (rs.x - 0.5) * layer.mb.x + (rs.y - 0.5) * layer.mb.y;
let coc = layer.mb.w * abs(z - layer.mb.z);
@@ -2117,7 +2131,8 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
i.local, layer.trail_a.xy, layer.trail_a.zw, layer.trail_b.xy, layer.trail_b.zw, layer.dst_prev.w,
);
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 {
+ // Sans antecedent sur le plan d'avant, pas de point d'avant : l'echantillon reste net.
+ if rp.z > -0.5 && dot(duv, duv) >= 1e-9 {
var acc = vec3<f32>(0.0);
let step = 1.0 / f32(trail_taps - 1);
for (var k: i32 = 0; k < 16; k = k + 1) {
diff --git a/crates/compositor/tests/screen_trail_render.rs b/crates/compositor/tests/screen_trail_render.rs
new file mode 100644
index 000000000..f06383456
--- /dev/null
+++ b/crates/compositor/tests/screen_trail_render.rs
@@ -0,0 +1,227 @@
+//! Le flou de mouvement de l'écran CADRÉ incliné (mode 18, `FrameGeometry::screen_trail`) rendu
+//! par le vrai compositeur D3D11, sur une source NV12 synthétique : rien à décoder, donc le test
+//! tourne sur toute machine qui a un GPU. Sans adaptateur matériel, il se saute (« test saute »).
+//!
+//! ```powershell
+//! cargo test -p openscreen-compositor --test screen_trail_render -- --nocapture
+//! $env:OPENSCREEN_TRAIL_OUT = "...\renders" # facultatif : les rendus comparés, en PNG
+//! ```
+
+#![cfg(windows)]
+
+use openscreen_compositor::compositor::Compositor;
+use openscreen_compositor::config::Cfg;
+use openscreen_compositor::d3d::Gpu;
+use openscreen_compositor::ffi::AVFrame;
+use openscreen_compositor::frame_geometry::live_params_from_scene;
+use openscreen_compositor::scene::Scene;
+use windows::core::Interface;
+use windows::Win32::Graphics::Direct3D11::{
+ ID3D11Texture2D, D3D11_BIND_SHADER_RESOURCE, D3D11_CPU_ACCESS_WRITE, D3D11_MAPPED_SUBRESOURCE,
+ D3D11_MAP_WRITE_DISCARD, D3D11_TEXTURE2D_DESC, D3D11_USAGE_DYNAMIC,
+};
+use windows::Win32::Graphics::Dxgi::Common::{DXGI_FORMAT_NV12, DXGI_SAMPLE_DESC};
+
+const W: u32 = 1280;
+const H: u32 = 720;
+const SRC: (u32, u32) = (640, 360);
+/// Les rampes du zoom de `scene_json` (2 à 6 s) : l'entrée finit à 2 s, la sortie part de 6 s.
+const RAMPS: [f32; 8] = [1.3, 1.5, 1.7, 1.9, 6.1, 6.3, 6.5, 6.7];
+
+fn gpu() -> Option<Gpu> {
+ match Gpu::create(false) {
+ Ok(g) => Some(g),
+ Err(e) => {
+ eprintln!("pas de device D3D11 matériel ({e:#}) — test saute");
+ None
+ }
+ }
+}
+
+/// Une frame NV12 synthétique : `yuv(colonne, rangée)` donne Y, Cb, Cr (BT.709 limité), la
+/// chroma étant prise au coin haut-gauche de chaque bloc 2×2.
+struct Source {
+ frame: Box<AVFrame>,
+ _tex: ID3D11Texture2D,
+}
+
+impl Source {
+ fn new(gpu: &Gpu, yuv: impl Fn(u32, u32) -> [u8; 3]) -> Source {
+ let (w, h) = SRC;
+ let desc = D3D11_TEXTURE2D_DESC {
+ Width: w,
+ Height: h,
+ MipLevels: 1,
+ ArraySize: 1,
+ Format: DXGI_FORMAT_NV12,
+ SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 },
+ Usage: D3D11_USAGE_DYNAMIC,
+ BindFlags: D3D11_BIND_SHADER_RESOURCE.0 as u32,
+ CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0 as u32,
+ MiscFlags: 0,
+ };
+ unsafe {
+ let mut tex: Option<ID3D11Texture2D> = None;
+ gpu.device.CreateTexture2D(&desc, None, Some(&mut tex)).expect("texture NV12");
+ let tex = tex.expect("texture NV12");
+ let mut m = D3D11_MAPPED_SUBRESOURCE::default();
+ gpu.context.Map(&tex, 0, D3D11_MAP_WRITE_DISCARD, 0, Some(&mut m)).expect("Map");
+ let pitch = m.RowPitch as usize;
+ let dst = m.pData as *mut u8;
+ for row in 0..h {
+ for col in 0..w {
+ *dst.add(row as usize * pitch + col as usize) = yuv(col, row)[0];
+ }
+ }
+ for row in 0..h / 2 {
+ for col in 0..w {
+ let [_, u, v] = yuv(col & !1, row * 2);
+ *dst.add((h + row) as usize * pitch + col as usize) = if col % 2 == 0 { u } else { v };
+ }
+ }
+ gpu.context.Unmap(&tex, 0);
+ let mut frame: Box<AVFrame> = Box::new(std::mem::zeroed());
+ frame.data[0] = tex.as_raw() as *mut u8;
+ frame.width = w as i32;
+ frame.height = h as i32;
+ Source { frame, _tex: tex }
+ }
+ }
+
+ fn as_ptr(&self) -> *const AVFrame {
+ &*self.frame as *const AVFrame
+ }
+}
+
+/// Un seul écran dans `rect` (fractions de la sortie `out`), zoomé ×`scale` sous `iso` de 2 à 6 s.
+/// Fond uni, sans ombre ni padding : hors de l'écran et de sa traînée, le pixel est le fond.
+fn scene_json(rect: [f32; 4], out: (u32, u32), scale: f32, roundness: f32, blur: f32, dof: bool) -> String {
+ let [x, y, w, h] = rect;
+ let (ow, oh) = out;
+ format!(
+ r##"{{"clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],
+ "layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false,
+ "screenRect":{{"x":{x},"y":{y},"width":{w},"height":{h}}}}},
+ "effects":{{"padding":0,"blur":false,"shadow":0,"roundnessFrac":{roundness},"motionBlur":{blur},"depthOfField":{dof}}},
+ "background":{{"kind":"color","color":"#6070a0"}},
+ "zoomRegions":[{{"clipIndex":0,"startSec":2,"endSec":6,"scale":{scale},"focusX":0.5,"focusY":0.5,"focusMode":"manual","rotation":"iso"}}],
+ "annotations":[],
+ "cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},
+ "cropByClip":[null],
+ "output":{{"width":{ow},"height":{oh},"fps":30}}}}"##
+ )
+}
+
+fn render(comp: &Compositor, src: &Source, json: &str, t: f32) -> Vec<u8> {
+ let scene = Scene::from_json(json).expect("scène valide");
+ let mut live = live_params_from_scene(&scene);
+ live.has_webcam = false;
+ comp.set_live_params(live);
+ comp.set_has_webcam(false);
+ comp.set_scene(Some(scene));
+ comp.clear_cursor();
+ comp.set_timeline_time(Some(t));
+ let mut cfg = Cfg::c8();
+ cfg.bg_blur = 0.0;
+ cfg.zoom = false;
+ cfg.layout_anim = false;
+ cfg.cursor = false;
+ cfg.mblur_n = 1;
+ cfg.shadow = false;
+ unsafe {
+ comp.compose_frame(src.as_ptr(), src.as_ptr(), 0.0, &cfg).expect("compose_frame");
+ comp.readback_direct().expect("readback").2
+ }
+}
+
+fn save(name: &str, rgba: &[u8], (w, h): (u32, u32)) {
+ let Ok(dir) = std::env::var("OPENSCREEN_TRAIL_OUT") else { return };
+ std::fs::create_dir_all(&dir).expect("dossier de sortie");
+ image::RgbaImage::from_raw(w, h, rgba.to_vec())
+ .expect("dimensions du readback")
+ .save(format!("{dir}/{name}.png"))
+ .unwrap_or_else(|e| panic!("écriture {name} : {e}"));
+}
+
+/// Un tap du mode 18 dont le warp inverse n'a PAS de solution (au-delà du pli du warp bilinéaire
+/// d'`iso`) est écarté. Il valait l'origine du plan, que le warp direct renvoyait sur le coin
+/// haut-gauche de l'écran courant : loin de l'écran, le fond prenait la couleur de ce coin, et
+/// un repère masqué par l'arrondi y reparaissait. Petit écran centré (15 % de la sortie), zoom
+/// ×1,6 : le coin bas-gauche de la sortie tombe au-delà du pli pendant les rampes. Là, et partout
+/// loin de l'écran, le rendu flouté doit rester le fond, au bit près.
+#[test]
+fn unsolvable_trail_taps_leave_the_background_alone() {
+ let Some(gpu) = gpu() else { return };
+ let comp = Compositor::new_sized(&gpu, W, H).expect("compositor");
+ // Métrage rouge, repère vert dans son coin haut-gauche (sous l'arrondi de l'écran).
+ let src = Source::new(&gpu, |col, row| if col < 48 && row < 48 { [173, 42, 26] } else { [63, 102, 240] });
+ let json = |blur| scene_json([0.425, 0.425, 0.15, 0.15], (W, H), 1.6, 0.02, blur, false);
+ let far = |x: u32, y: u32| x < W / 4 || x >= W * 3 / 4 || y < H / 4 || y >= H * 3 / 4;
+ let mut leaks = 0;
+ for t in RAMPS {
+ let sharp = render(&comp, &src, &json(0.0), t);
+ let blurred = render(&comp, &src, &json(1.0), t);
+ let n = (0..W * H)
+ .filter(|&i| far(i % W, i / W))
+ .filter(|&i| sharp[i as usize * 4..][..3] != blurred[i as usize * 4..][..3])
+ .count();
+ println!("t={t} : {n} px du fond changent avec le flou");
+ if n > 0 {
+ save(&format!("leak-{t}-sharp"), &sharp, (W, H));
+ save(&format!("leak-{t}-blurred"), &blurred, (W, H));
+ }
+ leaks += n;
+ }
+ assert_eq!(leaks, 0, "le flou de mouvement a peint loin de l'écran");
+}
+
+/// Hors de la sortie, le mode 18 relit le métrage lui-même : il doit le relire comme le mode 8
+/// l'a dessiné, profondeur de champ comprise. Même écran physique, zoomé ×2 sous `iso`, sur la
+/// sortie et au centre d'une sortie deux fois plus grande, où rien ne sort du cadre : aux bords
+/// de la sortie, les deux rendus coïncident. Le repli lisait le métrage NET : sur ces rayures de
+/// 2 px, des pixels du bord s'écartaient de la référence, grise de profondeur de champ, jusqu'à
+/// 89 niveaux (écart moyen 3,6). Seul écart admis, épars : la référence relit un rendu déjà
+/// échantillonné au pixel, le repli le métrage lui-même.
+#[test]
+fn off_canvas_trail_taps_keep_the_depth_of_field() {
+ let Some(gpu) = gpu() else { return };
+ // Rayures noires et blanches de 2 px : la profondeur de champ les grise.
+ let src = Source::new(&gpu, |col, _| [if col / 2 % 2 == 0 { 16 } else { 235 }, 128, 128]);
+ let normal = Compositor::new_sized(&gpu, W, H).expect("compositor");
+ let padded = Compositor::new_sized(&gpu, 2 * W, 2 * H).expect("compositor");
+ // La même boîte en px, centrée sur une sortie deux fois plus grande (le rayon se mesure sur
+ // la boîte, il ne change pas).
+ let json = |k: f32, dof| {
+ let r = [0.5 - 0.4 / k, 0.5 - 0.4 / k, 0.8 / k, 0.8 / k];
+ let out = ((W as f32 * k) as u32, (H as f32 * k) as u32);
+ scene_json(r, out, 2.0, 0.02, 1.0, dof)
+ };
+ // Les bords gauche et droit de la sortie, à mi-hauteur : le plan zoomé y déborde, et les taps
+ // de la rampe d'entrée tombent hors de la sortie.
+ let edges: Vec<(u32, u32)> = (H / 4..H * 3 / 4)
+ .flat_map(|y| (0..24).chain(W - 24..W).map(move |x| (x, y)))
+ .collect();
+ let at = |rgba: &[u8], w: u32, (x, y): (u32, u32)| rgba[((y * w + x) * 4) as usize];
+ // Le cœur de la rampe d'entrée : assez de mouvement pour que les taps sortent du cadre.
+ for t in [1.5, 1.7] {
+ let a = render(&normal, &src, &json(1.0, true), t);
+ let b = render(&padded, &src, &json(2.0, true), t);
+ let net = render(&normal, &src, &json(1.0, false), t);
+ let crop = |(x, y): (u32, u32)| (x + W / 2, y + H / 2);
+ let diffs: Vec<u8> = edges.iter().map(|&p| at(&a, W, p).abs_diff(at(&b, 2 * W, crop(p)))).collect();
+ let mean = diffs.iter().map(|&d| d as f32).sum::<f32>() / diffs.len() as f32;
+ let max = diffs.iter().copied().max().unwrap_or(0);
+ // Garde : la profondeur de champ change bien ces pixels, sinon il n'y a rien à comparer.
+ let dof = edges.iter().map(|&p| at(&a, W, p).abs_diff(at(&net, W, p))).max().unwrap_or(0);
+ // Et la pyramide est bien liée : elle grise les rayures sans les assombrir (non liée, le
+ // shader y lirait du noir, sur les deux sorties à la fois).
+ let level = |rgba: &[u8]| edges.iter().map(|&p| at(rgba, W, p) as f32).sum::<f32>() / edges.len() as f32;
+ let (lit, flat) = (level(&a), level(&net));
+ println!("t={t} : bord de la sortie, écart moyen {mean:.2}, max {max} (profondeur de champ : {dof}, niveau {lit:.1} / {flat:.1})");
+ save(&format!("dof-{t}-normal"), &a, (W, H));
+ save(&format!("dof-{t}-padded"), &b, (2 * W, 2 * H));
+ assert!(dof > 60, "t={t} : la profondeur de champ n'agit pas au bord, le test ne prouve rien");
+ assert!((lit - flat).abs() < 4.0, "t={t} : la profondeur de champ assombrit le bord ({lit:.1} / {flat:.1})");
+ assert!(mean < 1.0 && max <= 16, "t={t} : le bord perd la profondeur de champ ({mean:.2}, {max})");
+ }
+}