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
feat(compositor): continuous corners on every rounded shape
EtienneLescot6f7a3c10b70e
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rsindex 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.hlslindex 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 dediff --git a/crates/compositor/src/shaders.metal b/crates/compositor/src/shaders.metalindex 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 dudiff --git a/crates/compositor/src/vk_shaders/layer.wgsl b/crates/compositor/src/vk_shaders/layer.wgslindex 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