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): let the screen's edges follow the motion blur

EtienneLescot0d9bb409055b
diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rs
index 69feaa8cd..9f3276fc1 100644
--- a/crates/compositor/src/compositor_linux.rs
+++ b/crates/compositor/src/compositor_linux.rs
@@ -2069,10 +2069,7 @@ 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.
- // 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,
+ // 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() {
@@ -2089,7 +2086,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, square_top],
+ mb: [g.mb_taps, g.mb_amount, top_lift, g.screen_mb_w()],
..Default::default()
}
}
diff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rs
index 463fb02b2..d8f247cea 100644
--- a/crates/compositor/src/compositor_macos.rs
+++ b/crates/compositor/src/compositor_macos.rs
@@ -2220,7 +2220,6 @@ 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`).
@@ -2238,7 +2237,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, square_top],
+ mb: [g.mb_taps, g.mb_amount, top_lift, g.screen_mb_w()],
..Default::default()
},
&sy,
diff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rs
index 621986b58..997fb3391 100644
--- a/crates/compositor/src/compositor_windows.rs
+++ b/crates/compositor/src/compositor_windows.rs
@@ -1956,7 +1956,6 @@ 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);
@@ -2006,7 +2005,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, square_top],
+ mb: [mb_taps, mb_amount, top_lift, g.screen_mb_w()],
..Default::default()
},
&sy,
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rs
index 1688397ae..a76276526 100644
--- a/crates/compositor/src/frame_geometry.rs
+++ b/crates/compositor/src/frame_geometry.rs
@@ -1816,6 +1816,21 @@ 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 le chrome de fenêtre, qui est un calque
+ /// à part et resterait net.
+ pub fn screen_mb_w(&self) -> f32 {
+ let square_top = self.screen_square_top();
+ if square_top > 0.0 || self.screen_mask.is_some() {
+ square_top
+ } else {
+ -1.0
+ }
+ }
+
/// Sous le chrome de fenêtre, de combien son contour INTÉRIEUR remonte au-dessus du bord haut
/// de l'écran, en px de l'écran droit : la barre de titre moins le filet. 0 ailleurs.
///
@@ -3965,6 +3980,8 @@ 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 },
@@ -4024,6 +4041,7 @@ 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 21a3b705c..80c8993b7 100644
--- a/crates/compositor/src/shaders.hlsl
+++ b/crates/compositor/src/shaders.hlsl
@@ -26,10 +26,25 @@ 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);
@@ -117,6 +132,13 @@ 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
@@ -1698,20 +1720,30 @@ 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);
- acc += sample_yuv(uv_now - duv_blur * (1.0 - t));
+ 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;
}
- rgb = acc / (float) taps;
+ rgb = acc / max(cov, 1e-6);
+ if (trail) alpha_mask = cov / (float) taps;
}
// Effet d'arriere-plan webcam. fx.z : 1 = detourage, 2 = flou, 3 = fond personnalise.
@@ -1748,7 +1780,7 @@ float4 ps_main(VSOut i) : SV_Target
}
float alpha = color.a * alpha_mask;
- if (radius_px > 0.0)
+ if (radius_px > 0.0 && !edges_trail()) // sinon déjà dans alpha_mask
{
// `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 c7102fccf..08f349510 100644
--- a/crates/compositor/src/shaders.metal
+++ b/crates/compositor/src/shaders.metal
@@ -79,11 +79,26 @@ 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);
@@ -184,6 +199,13 @@ 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)
@@ -1655,20 +1677,29 @@ 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);
- acc += sample_yuv(uv_now - duv_blur * (1.0 - t), texY, texUV);
+ 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;
}
- rgb = acc / float(taps);
+ rgb = acc / max(cov, 1e-6);
+ if (trail) alpha_mask = cov / float(taps);
}
// Effet d'arriere-plan webcam. Miroir exact de la branche HLSL : fx.z porte le mode
@@ -1699,7 +1730,7 @@ fragment float4 ps_main(VSOut i [[stage_in]],
}
float alpha = layer.color.a * alpha_mask;
- if (layer.radius_px > 0.0)
+ if (layer.radius_px > 0.0 && !edges_trail(layer)) // sinon déjà dans alpha_mask
{
// 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 348b0cfc4..9aadcd494 100644
--- a/crates/compositor/src/vk_shaders/layer.wgsl
+++ b/crates/compositor/src/vk_shaders/layer.wgsl
@@ -55,11 +55,30 @@ 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)
- let c = vec2<f32>(f32(vid & 1u), f32((vid >> 1u) & 1u));
- let p = layer.dst.xy + c * layer.dst.zw;
+ 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 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);
@@ -1141,20 +1160,29 @@ 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; }
- acc = acc + sample_yuv(i.uv - duv_blur * (1.0 - f32(k) * step));
+ 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;
}
- rgb = acc / f32(taps);
+ rgb = acc / max(cov, 1e-6);
+ if trail { alpha_mask = cov / f32(taps); }
}
}
@@ -1493,7 +1521,7 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
alpha = layer.color.a * alpha_mask;
- if layer.radius_px > 0.0 {
+ if layer.radius_px > 0.0 && !edges_trail() { // sinon déjà dans alpha_mask
// 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.