Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
fix(compositor): motion-blur the framed screen as one object
EtienneLescot6953bc81c1e7
diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rsindex 9f3276fc1..de8b6b9b6 100644--- a/crates/compositor/src/compositor_linux.rs+++ b/crates/compositor/src/compositor_linux.rs@@ -278,6 +278,10 @@ pub struct Compositor {blur_half: wgpu::TextureView,blur_qtr: wgpu::TextureView,blur_oct: wgpu::TextureView,+ /// Rendu isole de l'ecran cadre (ombre, cadre, metrage, appareil), transparent autour, que+ /// le mode 18 recompose le long de sa trajectoire (`FrameGeometry::screen_trail`). Taille et+ /// format du RT : il est dessine par le meme pipeline.+ trail_view: wgpu::TextureView,// Render target offscreen + ring de staging de la relecture (recrees au resize).rt: wgpu::Texture,@@ -646,6 +650,7 @@ impl Compositor {let blur_half = mk_pyr(w / 2, h / 2, "blur-half");let blur_qtr = mk_pyr(w / 4, h / 4, "blur-qtr");let blur_oct = mk_pyr(w / 8, h / 8, "blur-oct");+ let trail_view = mk_pyr(w, h, "screen-trail");let (rt, rt_view, accum, accum_view, readback_bpr) = Self::make_targets(&gpu, w, h);let (ann_copy, ann_copy_view, ann_copy_mips) = Self::make_ann_copy(&gpu, w, h);@@ -680,6 +685,7 @@ impl Compositor {blur_half,blur_qtr,blur_oct,+ trail_view,rt,rt_view,_accum: accum,@@ -1175,6 +1181,32 @@ impl Compositor {}}+ /// L'ecran cadre, dans son ordre : ombre, cadre de fenetre (sous l'ecran), ecran, appareil+ /// (devant lui). Dans la passe d'avant-plan, ou dans le rendu isole du mode 18.+ fn draw_screen_group(+ &self,+ rpass: &mut wgpu::RenderPass<'_>,+ shadow: &Option<(wgpu::Buffer, wgpu::BindGroup)>,+ window_frame: &Option<(wgpu::Buffer, wgpu::BindGroup)>,+ screen: &wgpu::BindGroup,+ device_frame: &Option<(wgpu::Buffer, wgpu::BindGroup)>,+ ) {+ if let Some((_buf, bind)) = shadow {+ rpass.set_bind_group(0, bind, &[]);+ rpass.draw(0..4, 0..1);+ }+ if let Some((_buf, bind)) = window_frame {+ rpass.set_bind_group(0, bind, &[]);+ rpass.draw(0..4, 0..1);+ }+ rpass.set_bind_group(0, screen, &[]);+ rpass.draw(0..4, 0..1);+ if let Some((_buf, bind)) = device_frame {+ rpass.set_bind_group(0, bind, &[]);+ rpass.draw(0..4, 0..1);+ }+ }+fn make_bind(&self,cb: &LayerCB,@@ -2069,7 +2101,10 @@ impl Compositor {// `plane_px` dans `dst_prev`). Les deux sens ne peuvent pas cohabiter dans// un meme draw. macOS et Windows sautent egalement le flou sur le chemin// incline, pour la meme raison.- // La remontee du contour interieur du chrome au-dessus de l'ecran (`mb.z` au mode 0,+ // Sous un cadre de fenetre, l'ecran garde ses coins HAUTS carres (`mb.w` au mode 0,+ // `dst_prev.z` au mode 8) ; 0 sans cadre, soit le rendu d'avant.+ let square_top = g.screen_square_top();+ // Et la remontee du contour interieur du chrome au-dessus de l'ecran (`mb.z` au mode 0,// `color.z` au mode 8) : l'arrondi du haut se fait par le cadre. 0 sans fenetre.let top_lift = g.screen_top_lift_px([rw, rh]);let screen_layer = match tilt.as_ref() {@@ -2086,7 +2121,7 @@ impl Compositor {color: [1.0, 1.0, 1.0, 1.0],src_prev: g.cut,dst_prev: g.s_dst_prev,- mb: [g.mb_taps, g.mb_amount, top_lift, g.screen_mb_w()],+ mb: [g.screen_pixel_taps(), g.mb_amount, top_lift, square_top],..Default::default()}}@@ -2170,6 +2205,17 @@ impl Compositor {// du metrage et sa lunette mord dessus. Le shader s'arrete au plan du metrage dans// l'ouverture, donc il ne recouvre jamais l'image.let device_frame = g.device_frame_cb([rw, rh]).map(|cb| self.make_bind(&cb, None, &dummy));+ // Flou de mouvement de l'ecran CADRE (`FrameGeometry::screen_trail`) : l'ombre, le cadre,+ // le metrage et l'appareil ci-dessus passent dans un rendu isole (`trail_view`), que le+ // mode 18 recompose sur le fond ; binding 4 = ce rendu, les plans = le metrage.+ let trail = (tilt.is_none() && g.screen_trail()).then(|| {+ self.make_bind_b4(+ &g.screen_trail_cb([rw, rh]),+ Some((&sy, &su, &sv)),+ &dummy,+ Some(&self.trail_view),+ )+ });// Fond (gradient mode 5 OU image mode 6), dessine dans la passe de fond.let bg_draw = bg_layer.and_then(|bl| match bl {@@ -2898,6 +2944,25 @@ impl Compositor {}self.generate_mips(&mut encoder, &p.mips);}+ // Passe 0 bis : l'ecran cadre, isole sur transparent, quand il est floute en bloc.+ if trail.is_some() {+ let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {+ label: Some("screen-trail-pass"),+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {+ view: &self.trail_view,+ resolve_target: None,+ ops: wgpu::Operations {+ load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),+ store: wgpu::StoreOp::Store,+ },+ })],+ depth_stencil_attachment: None,+ timestamp_writes: None,+ occlusion_query_set: None,+ });+ rpass.set_pipeline(&self.pipeline);+ self.draw_screen_group(&mut rpass, &screen_shadow, &window_frame, &screen_bind, &device_frame);+ }// Passe 1 : fond (clear a `bg_clear` + gradient mode 5 eventuel).{let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {@@ -2951,19 +3016,18 @@ impl Compositor {// Chaque ombre est dessinee JUSTE AVANT le calque qu'elle porte :// elle doit passer sous lui mais au-dessus du fond (et, pour la// camera, au-dessus de l'ecran).- if let Some((_buf, bind)) = &screen_shadow {- rpass.set_bind_group(0, bind, &[]);- rpass.draw(0..4, 0..1);- }- if let Some((_buf, bind)) = &window_frame {- rpass.set_bind_group(0, bind, &[]);- rpass.draw(0..4, 0..1);- }- rpass.set_bind_group(0, &screen_bind, &[]);- rpass.draw(0..4, 0..1);- if let Some((_buf, bind)) = &device_frame {- rpass.set_bind_group(0, bind, &[]);- rpass.draw(0..4, 0..1);+ match &trail {+ Some((_buf, bind)) => {+ rpass.set_bind_group(0, bind, &[]);+ rpass.draw(0..4, 0..1);+ }+ None => self.draw_screen_group(+ &mut rpass,+ &screen_shadow,+ &window_frame,+ &screen_bind,+ &device_frame,+ ),}if let Some((_buf, bind)) = &webcam_shadow {rpass.set_bind_group(0, bind, &[]);@@ -4760,6 +4824,89 @@ mod tests {}}+ /// Ecran sous chrome de fenetre clair, zoome x1,3 de 1 s a 6 s, a l'instant `t` de la+ /// timeline, avec le flou de mouvement `blur` (0..1).+ fn compose_zooming_window(comp: &Compositor, gpu: &Gpu, t: f32, blur: f32) -> Vec<u8> {+ let json = format!(+ r##"{{"clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],+ "layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rounded",+ "webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false,+ "screenRect":{{"x":0.1,"y":0.1,"width":0.8,"height":0.8}}}},+ "effects":{{"padding":0.3,"blur":false,"shadow":0.6,"roundnessFrac":0.03,"motionBlur":{blur},"frame":"window-light"}},+ "background":{{"kind":"color","color":"#6070a0"}},+ "zoomRegions":[{{"clipIndex":0,"startSec":1,"endSec":6,"scale":1.3,"focusX":0.5,"focusY":0.5}}],+ "annotations":[],+ "cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,+ "clipToBounds":false,"theme":"default"}},+ "cropByClip":[null],+ "output":{{"width":1280,"height":720,"fps":30}}}}"##+ );+ 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 screen = FakeFrame::new(gpu, 640, 360, |_, _| 60);+ let webcam = FakeFrame::new(gpu, 64, 64, |_, _| 60);+ let mut cfg = Cfg::c8();+ cfg.bg_blur = false;+ cfg.cursor = false;+ cfg.mblur_n = 1;+ cfg.shadow = true;+ unsafe {+ comp.set_timeline_time(Some(t));+ comp.compose_frame(screen.as_ptr(), webcam.as_ptr(), 0.0, &cfg)+ .expect("compose_frame");+ let (_, _, rgba) = comp.readback_direct().expect("readback_direct");+ rgba+ }+ }++ /// Le flou de mouvement prend l'ecran CADRE en bloc : pendant la rampe du zoom, la barre de+ /// titre claire file avec le metrage au lieu de rester nette (elle perd des pixels francs,+ /// etales sur le fond et l'ecran). Immobile, le rendu flou est celui du rendu net, a l'octet.+ #[test]+ fn the_window_frame_trails_with_the_screen_under_motion_blur() {+ let Some(gpu) = gpu() else { return };+ let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");+ let bright = |rgba: &[u8]| {+ rgba.chunks_exact(4).filter(|p| p[0] > 215 && p[1] > 215 && p[2] > 215).count()+ };+ let still = 9.0;+ assert!(+ compose_zooming_window(&comp, &gpu, still, 0.0)+ == compose_zooming_window(&comp, &gpu, still, 1.0),+ "immobile, le flou ne doit rien changer"+ );+ let out_dir = std::env::var("OPENSCREEN_FRAME_OUT").ok();+ let mut best = (0.0f32, 0.0f32);+ // La rampe de sortie du zoom, ~6,0 s -> 6,8 s.+ for k in 0..=9 {+ let t = 5.9 + k as f32 * 0.1;+ let sharp = compose_zooming_window(&comp, &gpu, t, 0.0);+ let blurred = compose_zooming_window(&comp, &gpu, t, 1.0);+ // Encore zoome, la barre est hors champ : rien a mesurer a cet instant.+ if bright(&sharp) < 1000 {+ continue;+ }+ let drop = 1.0 - bright(&blurred) as f32 / bright(&sharp) as f32;+ if drop > best.0 {+ best = (drop, t);+ if let Some(dir) = &out_dir {+ for (name, rgba) in [("sharp", sharp), ("blurred", blurred)] {+ let path = format!("{dir}/linux-trail-{name}.png");+ image::RgbaImage::from_raw(1280, 720, rgba)+ .expect("dimensions du readback")+ .save(&path)+ .unwrap_or_else(|e| panic!("ecriture {path} : {e}"));+ }+ }+ }+ }+ eprintln!("barre de titre : -{:.1} % de pixels francs a t={}", best.0 * 100.0, best.1);+ let best = best.0;+ assert!(best > 0.05, "la barre de titre reste nette pendant le zoom (au mieux {best:.3})");+ }+/// Le cadre de fenetre (mode 14) se dessine sur Linux comme ailleurs : `"none"` rend/// l'image d'avant a l'octet, le theme clair ajoute une barre claire, droite comme/// inclinee, et les deux themes different. `OPENSCREEN_FRAME_OUT` recoit les PNG.diff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rsindex d8f247cea..42f35f9f5 100644--- a/crates/compositor/src/compositor_macos.rs+++ b/crates/compositor/src/compositor_macos.rs@@ -320,6 +320,10 @@ pub struct Compositor {/// le RT reviendrait à AJOUTER du blanc à ce qui est déjà dessous : sur un fond clair,/// le curseur disparaît. Même raisonnement que côté D3D11.accum: metal::Texture,+ /// Rendu isolé de l'écran cadré (ombre, cadre, métrage, appareil), transparent autour, que le+ /// mode 18 recompose le long de sa trajectoire (`FrameGeometry::screen_trail`). Distinct+ /// d'`accum`, que le curseur remplit dans la même frame.+ trail: metal::Texture,/// Pyramide dual-Kawase du flou de fond : demi, quart, huitième de la taille de rendu./// Dérivée de la taille de rendu et non d'une constante — sinon le rayon effectif du/// flou changerait avec la résolution de sortie.@@ -573,6 +577,14 @@ impl Compositor {metal::MTLStorageMode::Private,rt_usage,);+ let trail = make_texture(+ device,+ metal::MTLPixelFormat::RGBA8Unorm,+ rw,+ rh,+ metal::MTLStorageMode::Private,+ rt_usage,+ );let mut pyramid = [2u32, 4, 8].map(|d| {make_texture(device,@@ -643,6 +655,7 @@ impl Compositor {pipeline_fs_tex,pipeline_add,accum,+ trail,blur_half,blur_quarter,blur_eighth,@@ -2181,15 +2194,27 @@ impl Compositor {if scene_ref.as_ref().map(|s| s.effects.blur).unwrap_or(false) {self.blur_bg(cmd_buf)?;}- let enc = self.begin_pass(cmd_buf, &self.rt, None, &self.pipeline_main)?;- enc.set_fragment_texture(0, Some(&sy));- enc.set_fragment_texture(1, Some(&suv));-// --- écran : ombre puis vidéo ---let s_px = [g.s_dst[2] * rw, g.s_dst[3] * rh];// Géométrie du tilt calculée UNE fois : l'ombre et l'écran doivent porter exactement// le même quadrilatère, sinon l'ombre se décolle dès que l'un des deux change.let tilt = g.screen_tilt(s_px);+ // Flou de mouvement de l'écran CADRÉ (`FrameGeometry::screen_trail`) : ombre, cadre,+ // métrage et appareil se dessinent dans un rendu isolé et transparent, que le mode 18+ // recompose ensuite sur le fond le long de la trajectoire de la boîte.+ let trail = tilt.is_none() && g.screen_trail();+ let mut enc = if trail {+ self.begin_pass(+ cmd_buf,+ &self.trail,+ Some(metal::MTLClearColor::new(0.0, 0.0, 0.0, 0.0)),+ &self.pipeline_main,+ )?+ } else {+ self.begin_pass(cmd_buf, &self.rt, None, &self.pipeline_main)?+ };+ enc.set_fragment_texture(0, Some(&sy));+ enc.set_fragment_texture(1, Some(&suv));let quad_center_px = [(g.s_dst[0] + g.s_dst[2] * 0.5) * rw,(g.s_dst[1] + g.s_dst[3] * 0.5) * rh,@@ -2220,6 +2245,7 @@ impl Compositor {if let Some(cb) = g.window_frame_cb([rw, rh]) {self.draw_solid(enc, &cb);}+ let square_top = g.screen_square_top();let top_lift = g.screen_top_lift_px([rw, rh]);let [su0, sv0, su1, sv1] = g.cut;// Sous le masque d'un layout en bloc, rogné au slot (`FrameGeometry::mask_flat_screen`).@@ -2237,7 +2263,7 @@ impl Compositor {color: [0.0, 0.0, 0.0, 1.0],src_prev: [su0, sv0, su1, sv1],dst_prev: g.s_dst_prev,- mb: [g.mb_taps, g.mb_amount, top_lift, g.screen_mb_w()],+ mb: [g.screen_pixel_taps(), g.mb_amount, top_lift, square_top],..Default::default()},&sy,@@ -2264,6 +2290,12 @@ impl Compositor {if let Some(cb) = g.device_frame_cb([rw, rh]) {self.draw_solid(enc, &cb);}+ if trail {+ enc.end_encoding();+ enc = self.begin_pass(cmd_buf, &self.rt, None, &self.pipeline_main)?;+ enc.set_fragment_texture(2, Some(&self.trail));+ self.draw_video(enc, &g.screen_trail_cb([rw, rh]), &sy, &suv);+ }enc.end_encoding();diff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rsindex 997fb3391..b2443f7f0 100644--- a/crates/compositor/src/compositor_windows.rs+++ b/crates/compositor/src/compositor_windows.rs@@ -129,6 +129,11 @@ pub struct Compositor {accum_rtv: ID3D11RenderTargetView,accum_srv: ID3D11ShaderResourceView,blend_add: ID3D11BlendState,+ /// Rendu isolé de l'écran cadré (ombre, cadre, métrage, appareil), transparent autour, que le+ /// mode 18 recompose le long de sa trajectoire (`FrameGeometry::screen_trail`). Distinct de+ /// `accum`, que le curseur et `compose_frame_mb` remplissent dans la même frame.+ trail_rtv: ID3D11RenderTargetView,+ trail_srv: ID3D11ShaderResourceView,/// RefCell (pas un simple champ) pour que `set_cursor` reste `&self`, comme `set_scene` //// `set_live_params` — nécessaire pour le rebrancher par clip dans l'export multiclip, qui/// n'a qu'une référence partagée au `Compositor`.@@ -534,6 +539,7 @@ impl Compositor {let (half_b_rtv, half_b_srv) = mk_rgba(half_w, half_h)?;let (q_rtv, q_srv) = mk_rgba((half_w / 2).max(1), (half_h / 2).max(1))?;let (e_rtv, e_srv) = mk_rgba((half_w / 4).max(1), (half_h / 4).max(1))?;+ let (trail_rtv, trail_srv) = mk_rgba(out_w, out_h)?;// accumulateur pleine réso (RGBA) + blend additif pondéré (facteur = 1/N)let ad = D3D11_TEXTURE2D_DESC {@@ -623,6 +629,8 @@ impl Compositor {accum_rtv: accum_rtv.unwrap(),accum_srv: accum_srv.unwrap(),blend_add: blend_add.unwrap(),+ trail_rtv,+ trail_srv,cursor: RefCell::new(None),cursor_t_override: RefCell::new(None),timeline_t_override: RefCell::new(None),@@ -1933,6 +1941,14 @@ impl Compositor {// Avec un cadre de fenêtre, c'est le CADRE qui porte l'ombre (`shadow_caster`), sinon// elle tomberait sous l'écran seul et la barre de titre flotterait au-dessus.let render_px = [self.rw(), self.rh()];+ // Flou de mouvement de l'écran CADRÉ (`FrameGeometry::screen_trail`) : ombre, cadre,+ // métrage et appareil se dessinent dans un rendu isolé et transparent, que le mode 18+ // recompose ensuite sur le fond le long de la trajectoire de la boîte.+ let trail = tilt.is_none() && g.screen_trail();+ if trail {+ self.ctx.OMSetRenderTargets(Some(&[Some(self.trail_rtv.clone())]), None);+ self.ctx.ClearRenderTargetView(&self.trail_rtv, &[0.0, 0.0, 0.0, 0.0]);+ }if cfg.shadow {let spread = SCREEN_SHADOW_SPREAD_FRAC * frame_min_px;let offset = g.screen_shadow_offset();@@ -1956,6 +1972,7 @@ impl Compositor {if let Some(cb) = g.window_frame_cb(render_px) {self.draw_solid(&cb);}+ let square_top = g.screen_square_top();// Sous le chrome de fenetre, la remontee de son contour interieur au-dessus de l'ecran :// l'arrondi du haut se fait par le cadre (`screen_top_lift_px`). 0 sans fenetre.let top_lift = g.screen_top_lift_px(render_px);@@ -2005,7 +2022,7 @@ impl Compositor {color: [0.0, 0.0, 0.0, 1.0],src_prev: [su0_p, sv0_p, su0_p + 2.0 * hu_p, sv0_p + 2.0 * hv_p],dst_prev: s_dst_prev,- mb: [mb_taps, mb_amount, top_lift, g.screen_mb_w()],+ mb: [g.screen_pixel_taps(), mb_amount, top_lift, square_top],..Default::default()},&sy,@@ -2018,6 +2035,12 @@ impl Compositor {if let Some(cb) = g.device_frame_cb(render_px) {self.draw_solid(&cb);}+ if trail {+ self.ctx.OMSetRenderTargets(Some(&[Some(self.rtv.clone())]), None);+ self.ctx.PSSetShaderResources(2, Some(&[Some(self.trail_srv.clone())]));+ self.draw_video(&g.screen_trail_cb(render_px), &sy, &suv);+ self.ctx.PSSetShaderResources(2, Some(&[None]));+ }// --- curseur custom : suit le mapping src/dst (zoom+layout), click bounce,// et flou de mouvement (parité `compositor_macos.rs` et `compositor_linux.rs`) ---diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rsindex 33b3c5590..bf13c06a9 100644--- a/crates/compositor/src/frame_geometry.rs+++ b/crates/compositor/src/frame_geometry.rs@@ -1816,17 +1816,43 @@ impl FrameGeometry {}}- /// `mb.w` du mode 0 de l'écran droit : `screen_square_top`, ou -1 quand les BORDS du cadre- /// suivent le flou de mouvement. Le quad s'étend alors à la trace (`dst_prev`) et la- /// couverture des coins est moyennée sur les taps comme l'image : sans ça, sur un zoom avec- /// padding, le contenu file dans un cadre aux bords nets. Pas sous un masque de bloc (la case- /// ne bouge pas, seul le métrage bouge dedans) ni sous un cadre : le chrome de fenêtre- /// resterait net, et un appareil ne rogne pas l'écran, la traînée sortirait de sa coque.- pub fn screen_mb_w(&self) -> f32 {- if self.window_frame.is_none() && self.screen_mask.is_none() {- -1.0- } else {- self.screen_square_top()+ /// L'écran droit se déplace-t-il EN BLOC sous le flou de mouvement sur cette frame ?+ ///+ /// La coupe est la même aux deux frames : tout le mouvement de l'écran vient de sa boîte,+ /// `s_dst_prev` → `s_dst`, et l'ombre, le cadre et l'appareil sont taillés dans cette même+ /// boîte. C'est donc un objet rigide, et on le floute comme tel (mode 18, `screen_trail_cb`) :+ /// flouter le seul métrage laissait un contenu qui file dans un cadre aux bords nets.+ ///+ /// Pas sous un masque de bloc : la case ne bouge pas, seul le métrage bouge dedans, et le+ /// flou par pixel du mode 0 reste le bon. Le chemin incliné n'a pas de flou (l'appelant ne+ /// demande que sur écran droit).+ pub fn screen_trail(&self) -> bool {+ self.mb_taps >= 2.0+ && self.mb_amount > 0.001+ && self.s_dst != self.s_dst_prev+ && self.screen_mask.is_none()+ }++ /// Taps du flou PAR PIXEL du mode 0 de l'écran : un seul quand `screen_trail` floute déjà+ /// l'objet entier, sinon le métrage serait flouté deux fois.+ pub fn screen_pixel_taps(&self) -> f32 {+ if self.screen_trail() { 1.0 } else { self.mb_taps }+ }++ /// Le calque du mode 18 : le rendu isolé de l'écran cadré (t2), recomposé le long de sa+ /// trajectoire. `fx` = la boîte courante, `dst_prev` = la précédente, `src` = la coupe (le+ /// métrage relu directement là où le rendu isolé s'arrête au bord de la sortie).+ pub fn screen_trail_cb(&self, render_px: [f32; 2]) -> LayerCB {+ LayerCB {+ dst: [0.0, 0.0, 1.0, 1.0],+ src: self.cut,+ quad_px: render_px,+ 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],+ ..Default::default()}}@@ -3979,8 +4005,6 @@ mod tests {assert!(none.window_frame.is_none());assert!(none.window_frame_cb(RENDER).is_none());assert_eq!(none.screen_square_top(), 0.0);- // Sans cadre ni masque, les bords de l'écran suivent le flou de mouvement.- assert_eq!(none.screen_mb_w(), -1.0);let s_px = [none.s_dst[2] * RENDER[0], none.s_dst[3] * RENDER[1]];let expected = match none.screen_tilt_in(RENDER) {None => ShadowCaster::Upright { dst: none.s_dst, size_px: s_px, radius: none.s_radius },@@ -4028,13 +4052,28 @@ mod tests {}}- /// Un appareil ne rogne pas l'écran : si ses bords suivaient le flou de mouvement, la traînée- /// sortirait de la coque (constaté au rendu D3D11, téléphone sous un zoom 3,5x, #794).+ /// Le flou de mouvement prend l'écran cadré EN BLOC (ombre, cadre, appareil compris) dès que+ /// sa boîte bouge, et rend alors la main au flou par pixel du seul métrage ; jamais sous un+ /// masque de bloc, dont la case reste fixe.#[test]- fn a_device_frame_keeps_the_screen_edges_out_of_the_motion_blur() {- for frame in [r#","frame":"laptop""#, r#","frame":"phone""#, r#","frame":"monitor""#] {- let g = framed_plan(&framed_scene(frame, "null", 3.5, false));- assert_eq!(g.screen_mb_w(), 0.0, "{frame}");+ fn a_moving_screen_box_is_motion_blurred_as_one_object() {+ for frame in ["", r#","frame":"window""#, r#","frame":"phone""#] {+ let mut g = framed_plan(&framed_scene(frame, "null", 1.5, false));+ (g.mb_taps, g.mb_amount) = (16.0, 1.0);+ g.s_dst_prev = g.s_dst;+ assert!(!g.screen_trail(), "{frame}: boîte immobile");+ assert_eq!(g.screen_pixel_taps(), 16.0);+ g.s_dst_prev[2] *= 0.9;+ assert!(g.screen_trail(), "{frame}: boîte qui bouge");+ assert_eq!(g.screen_pixel_taps(), 1.0, "{frame}: flou compté deux fois");+ let cb = g.screen_trail_cb(RENDER);+ assert_eq!((cb.fx, cb.dst_prev, cb.src), (g.s_dst, g.s_dst_prev, g.cut));+ g.mb_amount = 0.0;+ assert!(!g.screen_trail(), "{frame}: flou coupé");+ g.mb_amount = 1.0;+ g.screen_mask = Some(ScreenMask { rect: [0.0, 0.0, 0.5, 1.0], radius_px: 0.0 });+ assert!(!g.screen_trail(), "{frame}: la case d'un bloc ne bouge pas");+ assert_eq!(g.screen_pixel_taps(), 16.0);}}@@ -4050,7 +4089,6 @@ mod tests {let wf = g.window_frame.expect("un cadre");assert_eq!(wf.dark, dark);assert_eq!(g.screen_square_top(), 1.0);- assert_eq!(g.screen_mb_w(), 1.0, "sous le chrome, les bords restent nets");assert_eq!(g.s_dst.map(f32::to_bits), old.s_dst.map(f32::to_bits), "le cadre a touché au métrage");assert_eq!(g.cut, old.cut, "le cadre a recadré la source");let ShadowCaster::Upright { dst: outer, size_px, radius } = g.shadow_caster(RENDER) else {diff --git a/crates/compositor/src/shaders.hlsl b/crates/compositor/src/shaders.hlslindex 80c8993b7..a52628e85 100644--- a/crates/compositor/src/shaders.hlsl+++ b/crates/compositor/src/shaders.hlsl@@ -7,7 +7,7 @@ cbuffer Layer : register(b0)float4 src; // u0,v0,u1,v1 dans l'espace source 0..1 ; modes 15 et 17 : décalage px du rayon, P, Ufloat2 quad_px; // taille du quad en pixels (pour les SDF)float radius_px; // rayon des coins arrondis en px (0 = aucun) ; mode 17 : rayon des coins hauts du corps (unités du modèle)- float mode; // 0 = vidéo NV12, 1 = couleur pleine, 2 = ombre portée, 4 = curseur, 15 = curseur 3D, 16 = impact du clic, 17 = appareil modelé+ float mode; // 0 = vidéo NV12, 1 = couleur pleine, 2 = ombre portée, 4 = curseur, 15 = curseur 3D, 16 = impact du clic, 17 = appareil modelé, 18 = écran cadré flouté en blocfloat4 color; // couleur pleine / teinte (ombre : rgb + opacité dans a) ; mode 15 : coin du sprite, écrasement, opacité ; mode 17 : .r = l'appareil (1 portable, 2 téléphone, 3 moniteur), .g = thème sombre, .b = rayon des coins bas du corps, .a = opacitéfloat4 fx; // fx.x = spread ombre (px), fx.y,fx.z libres ; mode 15 : rotation du plan (rad), tangage ; mode 17 : rotation du plan (rad), épaisseurfloat4 src_prev; // src à la frame précédente (flou de mouvement par vélocité) ; mode 15 : hotspot, lacet ; mode 17 : marges du corps (unités du modèle)@@ -26,25 +26,10 @@ struct VSOutfloat2 pout : TEXCOORD2; // position 0..1 sortie (pour la vélocité par pixel)};-// Mode 0, mb.w = -1 (`FrameGeometry::screen_mb_w`) : les bords du cadre suivent le flou de mouvement.-bool edges_trail()-{- return mode < 0.5 && mb.w < -0.5 && mb.x > 1.5 && mb.y > 0.001 && dst_prev.z > 0.0 && dst_prev.w > 0.0;-}-VSOut vs_main(uint vid : SV_VertexID){float2 c = float2(vid & 1, (vid >> 1) & 1); // strip: (0,0)(1,0)(0,1)(1,1)float2 p = dst.xy + c * dst.zw; // 0..1 sortie- if (edges_trail())- {- // Le quad couvre aussi la position précédente : la traînée des bords sort du rect courant.- // `c` sort alors de 0..1, uv et local s'extrapolent linéairement.- float2 lo = min(dst.xy, dst_prev.xy);- float2 hi = max(dst.xy + dst.zw, dst_prev.xy + dst_prev.zw);- p = lo + c * (hi - lo);- c = (p - dst.xy) / dst.zw;- }float2 ndc = float2(p.x * 2.0 - 1.0, 1.0 - p.y * 2.0);VSOut o;o.pos = float4(ndc, 0.0, 1.0);@@ -132,13 +117,6 @@ float sd_round_rect(float2 p, float2 halfsz, float r)return max(m.x, m.y) + min(max(q.x, q.y), 0.0) - e;}-// Couverture du quad arrondi en `local` (px du quad courant), feather ~1.5 px.-float quad_cov(float2 local)-{- float2 h = quad_px * 0.5;- return 1.0 - smoothstep(0.0, 1.5, sd_round_rect(local - h, h, radius_px));-}-// L'écran sous le chrome de FENÊTRE (modes 0 et 8) : coins HAUTS carrés, à ras de la barre de// titre, coins bas arrondis de `r`. L'arrondi du haut se fait une seule fois, par le cadre :// quand `r` dépasse la barre, l'arc du cadre descend sous elle et rogne les coins hauts de@@ -1302,6 +1280,38 @@ float4 device_frame(float2 local)float4 ps_main(VSOut i) : SV_Target{+ // mode 18 : l'écran CADRÉ (ombre, cadre, métrage, appareil) flouté comme UN objet rigide+ // (`FrameGeometry::screen_trail`). t2 = son rendu isolé, prémultiplié, à la taille de la+ // sortie ; sa boîte va de `dst_prev` (frame précédente) à `fx` (courante), fractions de sortie.+ // Chaque tap relit, dans le rendu courant, le point de l'objet qui couvrait ce pixel plus tôt+ // sur la trajectoire. Un point hors de la sortie n'a pas été rendu : dans l'écran, on relit le+ // métrage (`src` = la coupe) ; hors de l'écran (un bout de cadre hors champ), le tap est écarté.+ if (mode > 17.5)+ {+ int taps = (int) mb.x;+ float4 acc = 0.0;+ float n = 0.0;+ [loop] for (int k = 0; k < 16; k++)+ {+ if (k >= taps) break;+ float a = saturate(mb.y) * (1.0 - (float) k / (float) (taps - 1));+ float4 r = lerp(fx, dst_prev, a);+ float2 f = (i.pout - r.xy) / r.zw;+ float2 q = fx.xy + f * fx.zw;+ if (all(q >= 0.0) && all(q <= 1.0))+ {+ acc += texImg.SampleLevel(samp, q, 0.0);+ n += 1.0;+ }+ else if (all(f >= 0.0) && all(f <= 1.0))+ {+ acc += float4(sample_yuv(lerp(src.xy, src.zw, f)), 1.0);+ n += 1.0;+ }+ }+ return acc / max(n, 1.0);+ }+// mode 17 : CADRE D'APPAREIL MODELÉ (cf. `device_frame`). Testé en premier, comme le 16.if (mode > 16.5){@@ -1720,30 +1730,20 @@ float4 ps_main(VSOut i) : SV_Targetfloat mb_scale = saturate(mb.y);float2 duv_blur = duv * mb_scale;int taps = (int) mb.x;- // Bords qui suivent (`edges_trail`) : chaque tap porte aussi la couverture du cadre au- // point qu'il échantillonne, ramenée en px du quad courant par l'inverse du mapping src.- bool trail = edges_trail();- float2 duv_to_px = quad_px / (src.zw - src.xy);if (taps <= 1 || mb_scale <= 0.001 || dot(duv_blur, duv_blur) < 1e-9){rgb = sample_yuv(uv_now);- if (trail) alpha_mask = quad_cov(i.local);}else{float3 acc = 0.0;- float cov = 0.0;[loop] for (int k = 0; k < 16; k++){if (k >= taps) break;float t = (float) k / (float) (taps - 1);- float2 d = duv_blur * (1.0 - t);- float w = trail ? quad_cov(i.local - d * duv_to_px) : 1.0;- acc += sample_yuv(uv_now - d) * w;- cov += w;+ acc += sample_yuv(uv_now - duv_blur * (1.0 - t));}- rgb = acc / max(cov, 1e-6);- if (trail) alpha_mask = cov / (float) taps;+ rgb = acc / (float) taps;}// Effet d'arriere-plan webcam. fx.z : 1 = detourage, 2 = flou, 3 = fond personnalise.@@ -1780,7 +1780,7 @@ float4 ps_main(VSOut i) : SV_Target}float alpha = color.a * alpha_mask;- if (radius_px > 0.0 && !edges_trail()) // sinon déjà dans alpha_mask+ if (radius_px > 0.0){// `quad_px` est en px de SORTIE (le render target porte la géométrie de sortie) et// `radius_px` est un rayon réel en px de sortie : la SDF isotrope les compare dans lediff --git a/crates/compositor/src/shaders.metal b/crates/compositor/src/shaders.metalindex 08f349510..c7ee1ee55 100644--- a/crates/compositor/src/shaders.metal+++ b/crates/compositor/src/shaders.metal@@ -51,7 +51,7 @@ struct Layerfloat4 src; // u0,v0,u1,v1 dans l'espace source 0..1 ; modes 15 et 17 : décalage px du rayon, P, Ufloat2 quad_px; // taille du quad en pixels (pour les SDF)float radius_px; // rayon des coins arrondis en px (0 = aucun) ; mode 17 : rayon des coins hauts du corps (unités du modèle)- float mode; // 0 = vidéo NV12, 1 = couleur pleine, 2 = ombre portée, ..., 15 = curseur 3D, 16 = impact du clic, 17 = appareil modelé+ float mode; // 0 = vidéo NV12, 1 = couleur pleine, 2 = ombre portée, ..., 15 = curseur 3D, 16 = impact du clic, 17 = appareil modelé, 18 = écran cadré flouté en blocfloat4 color; // couleur pleine / teinte (ombre : rgb + opacité dans a) ; mode 15 : coin du sprite, texel, opacité ; mode 17 : .r = l'appareil (1 portable, 2 téléphone, 3 moniteur), .g = thème sombre, .b = rayon des coins bas du corps, .a = opacitéfloat4 fx; // fx.x = spread ombre (px), fx.y,fx.z libres ; mode 15 : rotation du plan (rad), tangage ; mode 17 : rotation du plan (rad), épaisseurfloat4 src_prev; // src à la frame précédente (flou de mouvement par vélocité) ; mode 15 : hotspot, lacet ; mode 17 : marges du corps (unités du modèle)@@ -79,26 +79,11 @@ struct VSOutfloat2 pout [[user(TEXCOORD2)]]; // position 0..1 sortie (pour la vélocité par pixel)};-// Mode 0, mb.w = -1 (`FrameGeometry::screen_mb_w`) : les bords du cadre suivent le flou de mouvement.-inline bool edges_trail(constant Layer &layer)-{- return layer.mode < 0.5 && layer.mb.w < -0.5 && layer.mb.x > 1.5 && layer.mb.y > 0.001- && layer.dst_prev.z > 0.0 && layer.dst_prev.w > 0.0;-}-vertex VSOut vs_main(uint vid [[vertex_id]],constant Layer &layer [[buffer(0)]]){float2 c = float2(vid & 1, (vid >> 1) & 1); // strip: (0,0)(1,0)(0,1)(1,1)float2 p = layer.dst.xy + c * layer.dst.zw; // 0..1 sortie- if (edges_trail(layer))- {- // Le quad couvre aussi la position précédente (parité HLSL `vs_main`).- float2 lo = min(layer.dst.xy, layer.dst_prev.xy);- float2 hi = max(layer.dst.xy + layer.dst.zw, layer.dst_prev.xy + layer.dst_prev.zw);- p = lo + c * (hi - lo);- c = (p - layer.dst.xy) / layer.dst.zw;- }float2 ndc = float2(p.x * 2.0 - 1.0, 1.0 - p.y * 2.0);VSOut o;o.pos = float4(ndc, 0.0, 1.0);@@ -199,13 +184,6 @@ inline float sd_round_rect(float2 p, float2 halfsz, float r)return max(m.x, m.y) + min(max(q.x, q.y), 0.0) - e;}-// Couverture du quad arrondi en `local` (px du quad courant), feather ~1.5 px.-inline float quad_cov(float2 local, constant Layer &layer)-{- float2 h = layer.quad_px * 0.5;- return 1.0 - smoothstep(0.0, 1.5, sd_round_rect(local - h, h, layer.radius_px));-}-// L'écran sous le chrome de FENÊTRE (modes 0 et 8) : coins HAUTS carrés, rognés par l'arc du// cadre quand le rayon dépasse la barre. Port de `sd_screen_under_bar` (HLSL), qui fait foi.inline float sd_screen_under_bar(float2 p, float2 halfsz, float r, float lift)@@ -1282,6 +1260,37 @@ fragment float4 ps_main(VSOut i [[stage_in]],// modes 7 et 13.texture2d<float, access::sample> texSdf [[texture(4)]]){+ // mode 18 : l'écran CADRÉ (ombre, cadre, métrage, appareil) flouté comme UN objet rigide+ // (`FrameGeometry::screen_trail`), port 1:1 du HLSL. texImg = son rendu isolé, prémultiplié,+ // à la taille de la sortie ; sa boîte va de `dst_prev` (frame précédente) à `fx` (courante).+ // Hors de la sortie rien n'a été rendu : dans l'écran on relit le métrage (`src` = la coupe),+ // hors de l'écran (un bout de cadre hors champ) le tap est écarté.+ if (layer.mode > 17.5)+ {+ int taps = int(layer.mb.x);+ float4 acc = float4(0.0);+ float n = 0.0;+ for (int k = 0; k < 16; k++)+ {+ if (k >= taps) break;+ float a = saturate(layer.mb.y) * (1.0 - float(k) / float(taps - 1));+ float4 r = mix(layer.fx, layer.dst_prev, a);+ float2 f = (i.pout - r.xy) / r.zw;+ float2 q = layer.fx.xy + f * layer.fx.zw;+ if (all(q >= 0.0) && all(q <= 1.0))+ {+ acc += texImg.sample(samp, q, level(0.0));+ n += 1.0;+ }+ else if (all(f >= 0.0) && all(f <= 1.0))+ {+ acc += float4(sample_yuv(mix(layer.src.xy, layer.src.zw, f), texY, texUV), 1.0);+ n += 1.0;+ }+ }+ return acc / max(n, 1.0);+ }+// mode 17 : CADRE D'APPAREIL MODELÉ (`device_frame`). Testé en premier, comme le 16.if (layer.mode > 16.5){@@ -1677,29 +1686,20 @@ fragment float4 ps_main(VSOut i [[stage_in]],float mb_scale = saturate(layer.mb.y);float2 duv_blur = duv * mb_scale;int taps = int(layer.mb.x);- // Bords qui suivent : couverture du cadre moyennée sur les taps (parité HLSL).- bool trail = edges_trail(layer);- float2 duv_to_px = layer.quad_px / (layer.src.zw - layer.src.xy);if (taps <= 1 || mb_scale <= 0.001 || dot(duv_blur, duv_blur) < 1e-9){rgb = sample_yuv(uv_now, texY, texUV);- if (trail) alpha_mask = quad_cov(i.local, layer);}else{float3 acc = float3(0.0);- float cov = 0.0;for (int k = 0; k < 16; k++){if (k >= taps) break;float t = float(k) / float(taps - 1);- float2 d = duv_blur * (1.0 - t);- float w = trail ? quad_cov(i.local - d * duv_to_px, layer) : 1.0;- acc += sample_yuv(uv_now - d, texY, texUV) * w;- cov += w;+ acc += sample_yuv(uv_now - duv_blur * (1.0 - t), texY, texUV);}- rgb = acc / max(cov, 1e-6);- if (trail) alpha_mask = cov / float(taps);+ rgb = acc / float(taps);}// Effet d'arriere-plan webcam. Miroir exact de la branche HLSL : fx.z porte le mode@@ -1730,7 +1730,7 @@ fragment float4 ps_main(VSOut i [[stage_in]],}float alpha = layer.color.a * alpha_mask;- if (layer.radius_px > 0.0 && !edges_trail(layer)) // sinon déjà dans alpha_mask+ if (layer.radius_px > 0.0){// mb.w = 1 : écran sous le chrome de fenêtre, coins HAUTS carrés et rognés par l'arc du// cadre (`sd_screen_under_bar`, `mb.z` = la remontée du contour intérieur, px).diff --git a/crates/compositor/src/vk_shaders/layer.wgsl b/crates/compositor/src/vk_shaders/layer.wgslindex 9aadcd494..69f3a4786 100644--- a/crates/compositor/src/vk_shaders/layer.wgsl+++ b/crates/compositor/src/vk_shaders/layer.wgsl@@ -55,30 +55,11 @@ struct VsOut {@location(2) pout: vec2<f32>, // position 0..1 sortie};-// Mode 0, mb.w = -1 (`FrameGeometry::screen_mb_w`) : les bords du cadre suivent le flou de mouvement.-fn edges_trail() -> bool {- return layer.mode < 0.5 && layer.mb.w < -0.5 && layer.mb.x > 1.5 && layer.mb.y > 0.001- && layer.dst_prev.z > 0.0 && layer.dst_prev.w > 0.0;-}--// Couverture du quad arrondi en `local` (px du quad courant), feather ~1.5 px.-fn quad_cov(local: vec2<f32>) -> f32 {- let h = layer.quad_px * 0.5;- return 1.0 - smoothstep(0.0, 1.5, sd_round_rect(local - h, h, layer.radius_px));-}-@vertexfn vs_main(@builtin(vertex_index) vid: u32) -> VsOut {// strip 4 vertices : (0,0)(1,0)(0,1)(1,1)- var c = vec2<f32>(f32(vid & 1u), f32((vid >> 1u) & 1u));- var p = layer.dst.xy + c * layer.dst.zw;- if edges_trail() {- // Le quad couvre aussi la position précédente (parité HLSL `vs_main`).- let lo = min(layer.dst.xy, layer.dst_prev.xy);- let hi = max(layer.dst.xy + layer.dst.zw, layer.dst_prev.xy + layer.dst_prev.zw);- p = lo + c * (hi - lo);- c = (p - layer.dst.xy) / layer.dst.zw;- }+ let c = vec2<f32>(f32(vid & 1u), f32((vid >> 1u) & 1u));+ let p = layer.dst.xy + c * layer.dst.zw;let ndc = vec2<f32>(p.x * 2.0 - 1.0, 1.0 - p.y * 2.0);var o: VsOut;o.pos = vec4<f32>(ndc, 0.0, 1.0);@@ -108,6 +89,42 @@ fn sample_yuv(uv: vec2<f32>) -> vec3<f32> {return yuv709_limited(y, cbcr);}+// `sample_yuv` à LOD explicite : utilisable hors du flot uniforme (mode 18).+fn sample_yuv_level(uv: vec2<f32>) -> vec3<f32> {+ let y = textureSampleLevel(texY, samp, uv, 0.0).r;+ let cbcr = vec2<f32>(+ textureSampleLevel(texU, samp, uv, 0.0).r,+ textureSampleLevel(texV, samp, uv, 0.0).r,+ );+ return yuv709_limited(y, cbcr);+}++// Mode 18 -- l'ecran CADRE (ombre, cadre, metrage, appareil) floute comme UN objet rigide+// (`FrameGeometry::screen_trail`), port 1:1 du HLSL. Binding 4 = son rendu isole, premultiplie,+// a la taille de la sortie ; sa boite va de `dst_prev` (frame precedente) a `fx` (courante).+// Chaque tap relit, dans le rendu courant, le point de l'objet qui couvrait ce pixel plus tot sur+// la trajectoire. Hors de la sortie rien n'a ete rendu : dans l'ecran on relit le metrage+// (`src` = la coupe), hors de l'ecran (un bout de cadre hors champ) le tap est ecarte.+fn screen_trail(pout: vec2<f32>) -> vec4<f32> {+ let taps = i32(layer.mb.x);+ var acc = vec4<f32>(0.0);+ var n = 0.0;+ for (var k: i32 = 0; k < 16; k = k + 1) {+ if k >= taps { break; }+ let a = clamp(layer.mb.y, 0.0, 1.0) * (1.0 - f32(k) / f32(taps - 1));+ let r = mix(layer.fx, layer.dst_prev, a);+ let f = (pout - r.xy) / r.zw;+ let q = layer.fx.xy + f * layer.fx.zw;+ let rendered = all(q >= vec2<f32>(0.0)) && all(q <= vec2<f32>(1.0));+ let in_screen = all(f >= vec2<f32>(0.0)) && all(f <= vec2<f32>(1.0));+ let group = textureSampleLevel(texMask, samp, q, 0.0);+ let footage = vec4<f32>(sample_yuv_level(mix(layer.src.xy, layer.src.zw, f)), 1.0);+ acc = acc + select(select(vec4<f32>(0.0), footage, in_screen), group, rendered);+ n = n + select(select(0.0, 1.0, in_screen), 1.0, rendered);+ }+ return acc / max(n, 1.0);+}+// SDF rectangle à coins arrondis (< 0 dedans). Identique au HLSL.//// Coins CONTINUS : le quart de coin est une superellipse d'exposant n, pas un arc de cercle.@@ -1160,29 +1177,20 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {let uv_prev = layer.src_prev.xy + localp * (layer.src_prev.zw - layer.src_prev.xy);let duv = i.uv - uv_prev;let duv_blur = duv * mb_scale;- // Bords qui suivent : couverture du cadre moyennée sur les taps (parité HLSL).- let trail = edges_trail();- let duv_to_px = layer.quad_px / (layer.src.zw - layer.src.xy);if dot(duv_blur, duv_blur) < 1e-9 {rgb = sample_yuv(i.uv);- if trail { alpha_mask = quad_cov(i.local); }} else {// Borne 16 en dur, identique au HLSL et au MSL : `taps` vient d'un// uniform et une boucle sans borne statique ne se déroule pas.// L'échelle de l'inspector s'arrête pile à 16 (1 + 15·blur), donc// c'est `taps` qui coupe, jamais la borne.var acc = vec3<f32>(0.0);- var cov = 0.0;let step = 1.0 / f32(taps - 1);for (var k: i32 = 0; k < 16; k = k + 1) {if k >= taps { break; }- let d = duv_blur * (1.0 - f32(k) * step);- let w = select(1.0, quad_cov(i.local - d * duv_to_px), trail);- acc = acc + sample_yuv(i.uv - d) * w;- cov = cov + w;+ acc = acc + sample_yuv(i.uv - duv_blur * (1.0 - f32(k) * step));}- rgb = acc / max(cov, 1e-6);- if trail { alpha_mask = cov / f32(taps); }+ rgb = acc / f32(taps);}}@@ -1509,6 +1517,9 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {} else if layer.mode > 16.5 && layer.mode < 17.5 {// Mode 17 -- cadre d'appareil modelise (`device_frame`).return device_frame(i.local);+ } else if layer.mode > 17.5 {+ // Mode 18 -- ecran cadre floute en bloc (`screen_trail`).+ return screen_trail(i.pout);} else {// Mode 2 — ombre portée (SDF d'un quad arrondi élargi de `fx.x`).let spread = layer.fx.x;@@ -1521,7 +1532,7 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {alpha = layer.color.a * alpha_mask;- if layer.radius_px > 0.0 && !edges_trail() { // sinon déjà dans alpha_mask+ if layer.radius_px > 0.0 {// Feather ~1.5 px sur le bord du quad — parité exacte avec le HLSL// (`smoothstep(0.0, 1.5, d)`). Le shader HLSL inclut `quad_px` en px de// SORTIE ; on reproduit la même chose ici.