Skip to content

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

fix(compositor): motion-blur the framed screen as one object

EtienneLescot6953bc81c1e7
diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rs
index 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.rs
index 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.rs
index 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.rs
index 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.hlsl
index 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, U
float2 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 bloc
float4 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), épaisseur
float4 src_prev; // src à la frame précédente (flou de mouvement par vélocité) ; mode 15 : hotspot, lacet ; mode 17 : marges du corps (unités du modèle)
@@ -26,25 +26,10 @@ struct VSOut
float2 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_Target
float 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 le
diff --git a/crates/compositor/src/shaders.metal b/crates/compositor/src/shaders.metal
index 08f349510..c7ee1ee55 100644
--- a/crates/compositor/src/shaders.metal
+++ b/crates/compositor/src/shaders.metal
@@ -51,7 +51,7 @@ struct Layer
float4 src; // u0,v0,u1,v1 dans l'espace source 0..1 ; modes 15 et 17 : décalage px du rayon, P, U
float2 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 bloc
float4 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), épaisseur
float4 src_prev; // src à la frame précédente (flou de mouvement par vélocité) ; mode 15 : hotspot, lacet ; mode 17 : marges du corps (unités du modèle)
@@ -79,26 +79,11 @@ struct VSOut
float2 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.wgsl
index 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));
-}
-
@vertex
fn 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.