Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
fix(compositor): 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.rsindex 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 cleardiff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rsindex 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.rsindex 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.rsindex 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.hlslindex 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 projectiffloat4 trail_a; // mode 8 : coins TL, TR du plan à la frame précédente (px locaux, comme fx) ; mode 18 incliné : en fractions de sortiefloat4 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.metalindex 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 c11float 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.wgslindex 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 projectiftrail_a: vec4<f32>, // mode 8 : coins TL, TR du plan a la frame precedente (px locaux, comme fx) ; mode 18 incline : en fractions de sortietrail_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.rsnew file mode 100644index 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})");+ }+}