Unify circular corner geometry and shader masks

compositor/src/render/shaders/blur_shader.frag

@@ -19,11 +19,11 @@ uniform float presentation_alpha;
 uniform float background_opacity;
 uniform vec4 tint;
 varying vec2 v_coords;
+//_CORNERS_
+
 void main() {
-    vec2 half_size = visible_rect.zw * 0.5;
-    vec2 d = abs(gl_FragCoord.xy - visible_rect.xy - half_size) - (half_size - vec2(material_radius));
-    float sdf = length(max(d, 0.0)) + min(max(d.x, d.y), 0.0) - material_radius;
-    float coverage = alpha * presentation_alpha * (1.0 - smoothstep(-0.5, 0.5, sdf));
+    float sdf = rounded_rect_distance(gl_FragCoord.xy, visible_rect, material_radius);
+    float coverage = alpha * presentation_alpha * edge_coverage(sdf);
     if (coverage <= 0.0) { gl_FragColor = vec4(0.0); return; }
     vec2 coords = (gl_FragCoord.xy - capture_origin) / texture_size;
     vec4 color = vec4(0.0);

compositor/src/render/shaders/corners.glsl

@@ -0,0 +1,10 @@
+// Coordinates and radius are physical pixels. Rust clamps the outer radius.
+float rounded_rect_distance(vec2 point, vec4 rect, float radius) {
+    vec2 half_size = rect.zw * 0.5;
+    vec2 d = abs(point - rect.xy - half_size) - (half_size - vec2(radius));
+    return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0) - radius;
+}
+
+float edge_coverage(float distance) {
+    return 1.0 - smoothstep(-0.5, 0.5, distance);
+}

compositor/src/render/shaders/material_shader.frag

@@ -9,17 +9,13 @@ uniform vec4 shadow_rect;
 uniform vec2 shadow_values;
 varying vec2 v_coords;
 
-float rounded_distance(vec2 point, vec4 rect) {
-    vec2 half_size = rect.zw * 0.5;
-    float radius = min(material_radius, min(half_size.x, half_size.y));
-    vec2 d = abs(point - rect.xy - half_size) - (half_size - vec2(radius));
-    return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0) - radius;
-}
+//_CORNERS_
+
 void main() {
-    float sdf = rounded_distance(gl_FragCoord.xy, visible_rect);
-    float coverage = 1.0 - smoothstep(-0.5, 0.5, sdf);
+    float sdf = rounded_rect_distance(gl_FragCoord.xy, visible_rect, material_radius);
+    float coverage = edge_coverage(sdf);
     if (paint_mode > 0.5) {
-        float distance = max(rounded_distance(gl_FragCoord.xy, shadow_rect), 0.0);
+        float distance = max(rounded_rect_distance(gl_FragCoord.xy, shadow_rect, material_radius), 0.0);
         float sigma = max(shadow_values.x * 0.5, 0.5);
         float opacity = exp(-0.5 * distance * distance / (sigma * sigma))
             * shadow_values.y * (1.0 - coverage) * alpha;

compositor/src/render/shaders/rounded_border_shader.frag

@@ -18,23 +18,16 @@ varying vec2 v_coords;
 uniform float tint;
 #endif
 
-void main() {
-    vec2 point = gl_FragCoord.xy - clip_rect.xy;
-    vec2 half_size = clip_rect.zw * 0.5;
-    vec2 distance = abs(point - half_size) - (half_size - vec2(radius));
-    float signed_distance = length(max(distance, 0.0))
-        + min(max(distance.x, distance.y), 0.0)
-        - radius;
-    float outer_coverage = 1.0 - smoothstep(-0.5, 0.5, signed_distance);
+//_CORNERS_
 
-    vec2 inner_half_size = max(half_size - vec2(border_width), vec2(0.0));
+void main() {
+    float signed_distance = rounded_rect_distance(gl_FragCoord.xy, clip_rect, radius);
+    float outer_coverage = edge_coverage(signed_distance);
+
+    vec2 inner_size = max(clip_rect.zw - vec2(2.0 * border_width), vec2(0.0));
+    vec4 inner_rect = vec4(clip_rect.xy + (clip_rect.zw - inner_size) * 0.5, inner_size);
     float inner_radius = max(radius - border_width, 0.0);
-    vec2 inner_distance = abs(point - half_size)
-        - (inner_half_size - vec2(inner_radius));
-    float inner_signed_distance = length(max(inner_distance, 0.0))
-        + min(max(inner_distance.x, inner_distance.y), 0.0)
-        - inner_radius;
-    float inner_coverage = 1.0 - smoothstep(-0.5, 0.5, inner_signed_distance);
+    float inner_coverage = edge_coverage(rounded_rect_distance(gl_FragCoord.xy, inner_rect, inner_radius));
     float coverage = max(outer_coverage - inner_coverage, 0.0);
     float progress = clamp(dot(gl_FragCoord.xy - gradient_line.xy, gradient_line.zw), 0.0, 1.0);
     // Interpolate premultiplied endpoints: a transparent endpoint must not

compositor/src/render/shaders/rounded_texture_shader.frag

@@ -22,6 +22,8 @@ varying vec2 v_coords;
 uniform float tint;
 #endif
 
+//_CORNERS_
+
 void main() {
     vec4 color = texture2D(tex, v_coords);
 
@@ -31,13 +33,8 @@ void main() {
     color = color * alpha;
 #endif
 
-    vec2 point = gl_FragCoord.xy - clip_rect.xy;
-    vec2 half_size = clip_rect.zw * 0.5;
-    vec2 distance = abs(point - half_size) - (half_size - vec2(radius));
-    float signed_distance = length(max(distance, 0.0))
-        + min(max(distance.x, distance.y), 0.0)
-        - radius;
-    float coverage = 1.0 - smoothstep(-0.5, 0.5, signed_distance);
+    float signed_distance = rounded_rect_distance(gl_FragCoord.xy, clip_rect, radius);
+    float coverage = edge_coverage(signed_distance);
     color *= coverage;
 
 #if defined(DEBUG_FLAGS)

compositor/src/render/shaders/window_shadow_shader.frag

@@ -13,13 +13,10 @@ varying vec2 v_coords;
 uniform float tint;
 #endif
 
+//_CORNERS_
+
 void main() {
-    vec2 point = gl_FragCoord.xy - shadow_rect.xy;
-    vec2 half_size = shadow_rect.zw * 0.5;
-    vec2 distance = abs(point - half_size) - (half_size - vec2(radius));
-    float signed_distance = length(max(distance, 0.0))
-        + min(max(distance.x, distance.y), 0.0)
-        - radius;
+    float signed_distance = rounded_rect_distance(gl_FragCoord.xy, shadow_rect, radius);
     float sigma = max(blur * 0.5, 0.5);
     float normalized_distance = max(signed_distance, 0.0) / sigma;
     float coverage = exp(-0.5 * normalized_distance * normalized_distance);