Skip to content

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

feat(compositor): continuous corners on every rounded shape

EtienneLescot6f7a3c10b70e
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rs
index 0a246e3de..9af3d361f 100644
--- a/crates/compositor/src/frame_geometry.rs
+++ b/crates/compositor/src/frame_geometry.rs
@@ -4223,7 +4223,8 @@ mod tests {
assert!((wf.radius[1] - (g.s_radius + line)).abs() < 1e-3, "r{roundness}: bas pas concentrique");
assert_eq!(wf.radius[0], wf.radius[1], "r{roundness}: le mode 14 n'a qu'un rayon");
// Le rognage du haut du metrage est le contour INTERIEUR du cadre : son contour
- // exterieur rentre du filet, rayon compris. Un seul arrondi, deux contours paralleles.
+ // exterieur rentre du filet, rayon compris. Un seul arrondi, deux contours paralleles
+ // -- a 2 % du filet pres depuis que les coins sont continus (`sd_round_rect`).
let (sw, sh) = (s_px[0] * 0.5, s_px[1] * 0.5);
for (x, y) in [(sw - 0.5, -sh + 0.5), (sw - 3.0, -sh + 2.0), (0.0, -sh + 0.5), (sw * 0.9, -sh * 0.9)] {
let inner = sd_round_rect_test([x, y + lift * 0.5], [sw, sh + lift * 0.5], g.s_radius);
@@ -4232,7 +4233,8 @@ mod tests {
[sw + line, sh + (bar + line) * 0.5],
wf.radius[0],
);
- assert!((inner - (outer + line)).abs() < 1e-2, "r{roundness} ({x},{y}): {inner} vs {outer} + {line}");
+ let tol = 0.02 * line + 1e-2;
+ assert!((inner - (outer + line)).abs() < tol, "r{roundness} ({x},{y}): {inner} vs {outer} + {line}");
}
// Le plafond de la fenêtre tient dans la barre : le coin haut du métrage reste
// entièrement carré, à toutes les positions du slider.
@@ -4711,11 +4713,53 @@ mod tests {
}
}
- /// `sd_round_rect` du shader, côté CPU : <0 dedans.
+ /// `sd_round_rect` du shader, côté CPU : <0 dedans. Coins continus, cf. le commentaire du
+ /// shader.
fn sd_round_rect_test(p: [f32; 2], half: [f32; 2], r: f32) -> f32 {
- let q = [p[0].abs() - half[0] + r, p[1].abs() - half[1] + r];
+ let hmin = half[0].min(half[1]);
+ if r <= 0.0 || hmin <= 0.0 {
+ let q = [p[0].abs() - half[0], p[1].abs() - half[1]];
+ let m = [q[0].max(0.0), q[1].max(0.0)];
+ return (m[0] * m[0] + m[1] * m[1]).sqrt() + q[0].max(q[1]).min(0.0);
+ }
+ let u = ((r / hmin - 0.5) / 0.5).clamp(0.0, 1.0);
+ let n = 3.0 - u * u * (3.0 - 2.0 * u);
+ let e = (r * 0.292_893_22 / (1.0 - (-1.0 / n).exp2())).min(hmin);
+ let q = [p[0].abs() - half[0] + e, p[1].abs() - half[1] + e];
let m = [q[0].max(0.0), q[1].max(0.0)];
- (m[0] * m[0] + m[1] * m[1]).sqrt() + q[0].max(q[1]).min(0.0) - r
+ if m[0] > 0.0 && m[1] > 0.0 {
+ let len = (m[0].powf(n) + m[1].powf(n)).powf(1.0 / n);
+ let g = [(m[0] / len).powf(n - 1.0), (m[1] / len).powf(n - 1.0)];
+ return (len - e) / (g[0] * g[0] + g[1] * g[1]).sqrt();
+ }
+ m[0].max(m[1]) + q[0].max(q[1]).min(0.0) - e
+ }
+
+ /// Les coins continus tiennent leurs trois promesses : le coin se creuse à 45° autant qu'un
+ /// cercle de même rayon (un réglage arrondit autant qu'avant), un carré arrondi à fond reste
+ /// un cercle, et la distance garde une pente de 1 sur le contour (antialiasing régulier).
+ #[test]
+ fn continuous_corners_keep_the_depth_the_circle_and_the_edge_width() {
+ let half = [300.0f32, 200.0];
+ for r in [8.0f32, 24.0, 60.0] {
+ let c = [half[0] - r, half[1] - r];
+ let on_circle = [c[0] + r * std::f32::consts::FRAC_1_SQRT_2, c[1] + r * std::f32::consts::FRAC_1_SQRT_2];
+ let d = sd_round_rect_test(on_circle, half, r);
+ assert!(d.abs() < 0.02, "r {r}: le coin à 45° est à {d} px de celui du cercle");
+ // Pente de la distance sur le contour, par différences finies.
+ let (h, p) = (0.01f32, [c[0] + r * 0.9, half[1] - 0.2]);
+ let gx = (sd_round_rect_test([p[0] + h, p[1]], half, r) - sd_round_rect_test([p[0] - h, p[1]], half, r)) / (2.0 * h);
+ let gy = (sd_round_rect_test([p[0], p[1] + h], half, r) - sd_round_rect_test([p[0], p[1] - h], half, r)) / (2.0 * h);
+ let slope = (gx * gx + gy * gy).sqrt();
+ assert!((slope - 1.0).abs() < 0.05, "r {r}: pente {slope} sur le contour");
+ }
+ // À fond, un carré est un cercle.
+ let square = [100.0f32, 100.0];
+ for p in [[0.0f32, 99.0], [70.0, 70.0], [60.0, 90.0], [120.0, 20.0]] {
+ let circle = (p[0] * p[0] + p[1] * p[1]).sqrt() - 100.0;
+ let d = sd_round_rect_test(p, square, 100.0);
+ assert!((d - circle).abs() < 1e-2, "{p:?}: {d} au lieu de {circle}");
+ }
}
/// La même scène, zoomée ET inclinée par un préset de rotation 3D.
diff --git a/crates/compositor/src/shaders.hlsl b/crates/compositor/src/shaders.hlsl
index 187a14676..e6e5e7a5f 100644
--- a/crates/compositor/src/shaders.hlsl
+++ b/crates/compositor/src/shaders.hlsl
@@ -86,10 +86,35 @@ float sd_segment(float2 p, float2 a, float2 b)
}
// SDF rectangle à coins arrondis (§7 E2) : <0 dedans.
+//
+// Coins CONTINUS : le quart de coin est une superellipse d'exposant n, pas un arc de cercle.
+// Un arc rejoint le bord droit sans angle, mais sa courbure y saute d'un coup de 0 à 1/r, et
+// l'œil lit ce saut comme une cassure ; ici elle monte en douceur depuis zéro (les coins
+// « continus » d'Apple). `r` garde son sens : l'étendue E = K(n)·r creuse le coin à 45° autant
+// qu'un cercle de rayon r, donc un réglage arrondit autant qu'avant, et deux contours
+// concentriques (r, et r + b autour) gardent une bordure d'épaisseur b à 2 % près. L'exposant
+// revient à 2 quand r approche le demi-petit-côté : à fond, un carré est un cercle et un
+// rectangle une pilule. La distance est divisée par la pente de la norme, donc l'antialiasing
+// garde sa largeur tout autour du coin. r <= 0 : le rectangle vif d'avant, à l'identique.
float sd_round_rect(float2 p, float2 halfsz, float r)
{
- float2 q = abs(p) - halfsz + r;
- return length(max(q, 0.0)) + min(max(q.x, q.y), 0.0) - r;
+ float hmin = min(halfsz.x, halfsz.y);
+ if (r <= 0.0 || hmin <= 0.0)
+ {
+ float2 q0 = abs(p) - halfsz;
+ return length(max(q0, 0.0)) + min(max(q0.x, q0.y), 0.0);
+ }
+ float n = 3.0 - smoothstep(0.5, 1.0, r / hmin);
+ float e = min(r * 0.29289322 / (1.0 - exp2(-1.0 / n)), hmin);
+ float2 q = abs(p) - halfsz + e;
+ float2 m = max(q, 0.0);
+ if (m.x > 0.0 && m.y > 0.0)
+ {
+ float len = pow(pow(m.x, n) + pow(m.y, n), 1.0 / n);
+ float2 g = pow(m / len, float2(n - 1.0, n - 1.0));
+ return (len - e) / length(g);
+ }
+ return max(m.x, m.y) + min(max(q.x, q.y), 0.0) - e;
}
// L'écran sous le chrome de FENÊTRE (modes 0 et 8) : coins HAUTS carrés, à ras de la barre de
diff --git a/crates/compositor/src/shaders.metal b/crates/compositor/src/shaders.metal
index 7471eca23..7c3bb9576 100644
--- a/crates/compositor/src/shaders.metal
+++ b/crates/compositor/src/shaders.metal
@@ -153,10 +153,35 @@ inline float sd_segment(float2 p, float2 a, float2 b)
}
// SDF rectangle à coins arrondis (§7 E2) : <0 dedans.
+//
+// Coins CONTINUS : le quart de coin est une superellipse d'exposant n, pas un arc de cercle.
+// Un arc rejoint le bord droit sans angle, mais sa courbure y saute d'un coup de 0 à 1/r, et
+// l'œil lit ce saut comme une cassure ; ici elle monte en douceur depuis zéro (les coins
+// « continus » d'Apple). `r` garde son sens : l'étendue E = K(n)·r creuse le coin à 45° autant
+// qu'un cercle de rayon r, donc un réglage arrondit autant qu'avant, et deux contours
+// concentriques (r, et r + b autour) gardent une bordure d'épaisseur b à 2 % près. L'exposant
+// revient à 2 quand r approche le demi-petit-côté : à fond, un carré est un cercle et un
+// rectangle une pilule. La distance est divisée par la pente de la norme, donc l'antialiasing
+// garde sa largeur tout autour du coin. r <= 0 : le rectangle vif d'avant, à l'identique.
inline float sd_round_rect(float2 p, float2 halfsz, float r)
{
- float2 q = abs(p) - halfsz + r;
- return length(max(q, 0.0)) + min(max(q.x, q.y), 0.0) - r;
+ float hmin = min(halfsz.x, halfsz.y);
+ if (r <= 0.0 || hmin <= 0.0)
+ {
+ float2 q0 = abs(p) - halfsz;
+ return length(max(q0, 0.0)) + min(max(q0.x, q0.y), 0.0);
+ }
+ float n = 3.0 - smoothstep(0.5, 1.0, r / hmin);
+ float e = min(r * 0.29289322 / (1.0 - exp2(-1.0 / n)), hmin);
+ float2 q = abs(p) - halfsz + e;
+ float2 m = max(q, 0.0);
+ if (m.x > 0.0 && m.y > 0.0)
+ {
+ float len = pow(pow(m.x, n) + pow(m.y, n), 1.0 / n);
+ float2 g = pow(m / len, float2(n - 1.0));
+ return (len - e) / length(g);
+ }
+ return max(m.x, m.y) + min(max(q.x, q.y), 0.0) - e;
}
// L'écran sous le chrome de FENÊTRE (modes 0 et 8) : coins HAUTS carrés, rognés par l'arc du
diff --git a/crates/compositor/src/vk_shaders/layer.wgsl b/crates/compositor/src/vk_shaders/layer.wgsl
index 0ec5b3454..8748ed27e 100644
--- a/crates/compositor/src/vk_shaders/layer.wgsl
+++ b/crates/compositor/src/vk_shaders/layer.wgsl
@@ -90,9 +90,32 @@ fn sample_yuv(uv: vec2<f32>) -> vec3<f32> {
}
// 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.
+// Un arc rejoint le bord droit sans angle, mais sa courbure y saute d'un coup de 0 à 1/r, et
+// l'œil lit ce saut comme une cassure ; ici elle monte en douceur depuis zéro (les coins
+// « continus » d'Apple). `r` garde son sens : l'étendue E = K(n)·r creuse le coin à 45° autant
+// qu'un cercle de rayon r, donc un réglage arrondit autant qu'avant, et deux contours
+// concentriques (r, et r + b autour) gardent une bordure d'épaisseur b à 2 % près. L'exposant
+// revient à 2 quand r approche le demi-petit-côté : à fond, un carré est un cercle et un
+// rectangle une pilule. La distance est divisée par la pente de la norme, donc l'antialiasing
+// garde sa largeur tout autour du coin. r <= 0 : le rectangle vif d'avant, à l'identique.
fn sd_round_rect(p: vec2<f32>, halfsz: vec2<f32>, r: f32) -> f32 {
- let q = abs(p) - halfsz + vec2<f32>(r);
- return length(max(q, vec2<f32>(0.0))) + min(max(q.x, q.y), 0.0) - r;
+ let hmin = min(halfsz.x, halfsz.y);
+ if (r <= 0.0 || hmin <= 0.0) {
+ let q0 = abs(p) - halfsz;
+ return length(max(q0, vec2<f32>(0.0))) + min(max(q0.x, q0.y), 0.0);
+ }
+ let n = 3.0 - smoothstep(0.5, 1.0, r / hmin);
+ let e = min(r * 0.29289322 / (1.0 - exp2(-1.0 / n)), hmin);
+ let q = abs(p) - halfsz + vec2<f32>(e);
+ let m = max(q, vec2<f32>(0.0));
+ if (m.x > 0.0 && m.y > 0.0) {
+ let len = pow(pow(m.x, n) + pow(m.y, n), 1.0 / n);
+ let g = pow(m / len, vec2<f32>(n - 1.0));
+ return (len - e) / length(g);
+ }
+ return max(m.x, m.y) + min(max(q.x, q.y), 0.0) - e;
}
// L'ecran sous le chrome de FENETRE (modes 0 et 8) : coins HAUTS carres, rognes par l'arc du