structure: moved fx_renderer and related fuctions to a folder

8 files changed, 262 insertions, 0 deletions

diff --git a/sway/desktop/fx_renderer/shaders/box_shadow.frag b/sway/desktop/fx_renderer/shaders/box_shadow.frag
new file mode 100644
index 00000000..c9b2b91f
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/box_shadow.frag
@@ -0,0 +1,74 @@
+// Writeup: https://madebyevan.com/shaders/fast-rounded-rectangle-shadows/
+
+precision mediump float;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+uniform vec2 position;
+uniform vec2 size;
+uniform float blur_sigma;
+uniform float corner_radius;
+
+float gaussian(float x, float sigma) {
+    const float pi = 3.141592653589793;
+    return exp(-(x * x) / (2.0 * sigma * sigma)) / (sqrt(2.0 * pi) * sigma);
+}
+
+// approximates the error function, needed for the gaussian integral
+vec2 erf(vec2 x) {
+    vec2 s = sign(x), a = abs(x);
+    x = 1.0 + (0.278393 + (0.230389 + 0.078108 * (a * a)) * a) * a;
+    x *= x;
+    return s - s / (x * x);
+}
+
+// return the blurred mask along the x dimension
+float roundedBoxShadowX(float x, float y, float sigma, float corner, vec2 halfSize) {
+    float delta = min(halfSize.y - corner - abs(y), 0.0);
+    float curved = halfSize.x - corner + sqrt(max(0.0, corner * corner - delta * delta));
+    vec2 integral = 0.5 + 0.5 * erf((x + vec2(-curved, curved)) * (sqrt(0.5) / sigma));
+    return integral.y - integral.x;
+}
+
+// return the mask for the shadow of a box from lower to upper
+float roundedBoxShadow(vec2 lower, vec2 upper, vec2 point, float sigma, float corner_radius) {
+    // Center everything to make the math easier
+    vec2 center = (lower + upper) * 0.5;
+    vec2 halfSize = (upper - lower) * 0.5;
+    point -= center;
+
+    // The signal is only non-zero in a limited range, so don't waste samples
+    float low = point.y - halfSize.y;
+    float high = point.y + halfSize.y;
+    float start = clamp(-3.0 * sigma, low, high);
+    float end = clamp(3.0 * sigma, low, high);
+
+    // Accumulate samples (we can get away with surprisingly few samples)
+    float step = (end - start) / 4.0;
+    float y = start + step * 0.5;
+    float value = 0.0;
+    for (int i = 0; i < 4; i++) {
+        value += roundedBoxShadowX(point.x, point.y - y, sigma, corner_radius, halfSize) * gaussian(y, sigma) * step;
+        y += step;
+    }
+
+    return value;
+}
+
+// per-pixel "random" number between 0 and 1
+float random() {
+    return fract(sin(dot(vec2(12.9898, 78.233), gl_FragCoord.xy)) * 43758.5453);
+}
+
+void main() {
+    float frag_alpha = v_color.a * roundedBoxShadow(
+            position + blur_sigma,
+            position + size - blur_sigma,
+            gl_FragCoord.xy, blur_sigma * 0.5,
+            corner_radius);
+
+    // dither the alpha to break up color bands
+    frag_alpha += (random() - 0.5) / 128.0;
+
+    gl_FragColor = vec4(v_color.rgb, frag_alpha);
+}
diff --git a/sway/desktop/fx_renderer/shaders/common.vert b/sway/desktop/fx_renderer/shaders/common.vert
new file mode 100644
index 00000000..811e0f2d
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/common.vert
@@ -0,0 +1,12 @@
+uniform mat3 proj;
+uniform vec4 color;
+attribute vec2 pos;
+attribute vec2 texcoord;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+void main() {
+    gl_Position = vec4(proj * vec3(pos, 1.0), 1.0);
+    v_color = color;
+    v_texcoord = texcoord;
+}
diff --git a/sway/desktop/fx_renderer/shaders/corner.frag b/sway/desktop/fx_renderer/shaders/corner.frag
new file mode 100644
index 00000000..7699299a
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/corner.frag
@@ -0,0 +1,36 @@
+precision mediump float;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+uniform bool is_top_left;
+uniform bool is_top_right;
+uniform bool is_bottom_left;
+uniform bool is_bottom_right;
+
+uniform vec2 position;
+uniform float radius;
+uniform vec2 half_size;
+uniform float half_thickness;
+
+float roundedBoxSDF(vec2 center, vec2 size, float radius) {
+    return length(max(abs(center) - size + radius, 0.0)) - radius;
+}
+
+void main() {
+    vec2 center = gl_FragCoord.xy - position - half_size;
+    float distance = roundedBoxSDF(center, half_size - half_thickness, radius + half_thickness);
+    float smoothedAlphaOuter = 1.0 - smoothstep(-1.0, 1.0, distance - half_thickness);
+    // Create an inner circle that isn't as anti-aliased as the outer ring
+    float smoothedAlphaInner = 1.0 - smoothstep(-1.0, 0.5, distance + half_thickness);
+    gl_FragColor = mix(vec4(0), v_color, smoothedAlphaOuter - smoothedAlphaInner);
+
+    if (is_top_left && (center.y > 0.0 || center.x > 0.0)) {
+        discard;
+    } else if (is_top_right && (center.y > 0.0 || center.x < 0.0)) {
+        discard;
+    } else if (is_bottom_left && (center.y < 0.0 || center.x > 0.0)) {
+        discard;
+    } else if (is_bottom_right && (center.y < 0.0 || center.x < 0.0)) {
+        discard;
+    }
+}
diff --git a/sway/desktop/fx_renderer/shaders/embed.sh b/sway/desktop/fx_renderer/shaders/embed.sh
new file mode 100644
index 00000000..47f07892
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/embed.sh
@@ -0,0 +1,11 @@
+#!/bin/sh -eu
+
+var=${1:-data}
+hex="$(od -A n -t x1 -v)"
+
+echo "static const char $var[] = {"
+for byte in $hex; do
+    echo "	0x$byte,"
+done
+echo "	0x00,"
+echo "};"
diff --git a/sway/desktop/fx_renderer/shaders/meson.build b/sway/desktop/fx_renderer/shaders/meson.build
new file mode 100644
index 00000000..6c0dd1d3
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/meson.build
@@ -0,0 +1,23 @@
+embed = find_program('./embed.sh', native: true)
+
+shaders = [
+    'box_shadow.frag',
+    'common.vert',
+    'corner.frag',
+    'quad.frag',
+    'quad_round.frag',
+    'tex.frag',
+]
+
+foreach name : shaders
+    output = name.underscorify() + '_src.h'
+    var = name.underscorify() + '_src'
+    sway_sources += custom_target(
+        output,
+        command: [embed, var],
+        input: name,
+        output: output,
+        feed: true,
+        capture: true,
+    )
+endforeach
diff --git a/sway/desktop/fx_renderer/shaders/quad.frag b/sway/desktop/fx_renderer/shaders/quad.frag
new file mode 100644
index 00000000..7c763272
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/quad.frag
@@ -0,0 +1,7 @@
+precision mediump float;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+void main() {
+    gl_FragColor = v_color;
+}
diff --git a/sway/desktop/fx_renderer/shaders/quad_round.frag b/sway/desktop/fx_renderer/shaders/quad_round.frag
new file mode 100644
index 00000000..4dcf0c53
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/quad_round.frag
@@ -0,0 +1,37 @@
+#define SOURCE_QUAD_ROUND 1
+#define SOURCE_QUAD_ROUND_TOP_LEFT 2
+#define SOURCE_QUAD_ROUND_TOP_RIGHT 3
+
+#if !defined(SOURCE)
+#error "Missing shader preamble"
+#endif
+
+precision mediump float;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+uniform vec2 size;
+uniform vec2 position;
+uniform float radius;
+
+vec2 getCornerDist() {
+#if SOURCE == SOURCE_QUAD_ROUND
+    vec2 half_size = size * 0.5;
+    return abs(gl_FragCoord.xy - position - half_size) - half_size + radius;
+#elif SOURCE == SOURCE_QUAD_ROUND_TOP_LEFT
+    return abs(gl_FragCoord.xy - position - size) - size + radius;
+#elif SOURCE == SOURCE_QUAD_ROUND_TOP_RIGHT
+    return abs(gl_FragCoord.xy - position - vec2(0, size.y)) - size + radius;
+#endif
+}
+
+void main() {
+    vec2 q = getCornerDist();
+    float dist = min(max(q.x,q.y), 0.0) + length(max(q, 0.0)) - radius;
+    float smoothedAlpha = 1.0 - smoothstep(-1.0, 0.5, dist);
+    gl_FragColor = mix(vec4(0), v_color, smoothedAlpha);
+
+    if (gl_FragColor.a == 0.0) {
+        discard;
+    }
+}
diff --git a/sway/desktop/fx_renderer/shaders/tex.frag b/sway/desktop/fx_renderer/shaders/tex.frag
new file mode 100644
index 00000000..817b838c
--- /dev/null
+++ b/sway/desktop/fx_renderer/shaders/tex.frag
@@ -0,0 +1,62 @@
+#define SOURCE_TEXTURE_RGBA 1
+#define SOURCE_TEXTURE_RGBX 2
+#define SOURCE_TEXTURE_EXTERNAL 3
+
+#if !defined(SOURCE)
+#error "Missing shader preamble"
+#endif
+
+#if SOURCE == SOURCE_TEXTURE_EXTERNAL
+#extension GL_OES_EGL_image_external : require
+#endif
+
+precision mediump float;
+
+varying vec2 v_texcoord;
+
+#if SOURCE == SOURCE_TEXTURE_EXTERNAL
+uniform samplerExternalOES tex;
+#elif SOURCE == SOURCE_TEXTURE_RGBA || SOURCE == SOURCE_TEXTURE_RGBX
+uniform sampler2D tex;
+#endif
+
+uniform float alpha;
+uniform float dim;
+uniform vec4 dim_color;
+uniform vec2 size;
+uniform vec2 position;
+uniform float radius;
+uniform bool has_titlebar;
+uniform float saturation;
+
+const vec3 saturation_weight = vec3(0.2125, 0.7154, 0.0721);
+
+vec4 sample_texture() {
+#if SOURCE == SOURCE_TEXTURE_RGBA || SOURCE == SOURCE_TEXTURE_EXTERNAL
+    return texture2D(tex, v_texcoord);
+#elif SOURCE == SOURCE_TEXTURE_RGBX
+    return vec4(texture2D(tex, v_texcoord).rgb, 1.0);
+#endif
+}
+
+void main() {
+    vec4 color = sample_texture();
+    // Saturation
+    if (saturation != 1.0) {
+        vec4 pixColor = texture2D(tex, v_texcoord);
+        vec3 irgb = pixColor.rgb;
+        vec3 target = vec3(dot(irgb, saturation_weight));
+        color = vec4(mix(target, irgb, saturation), pixColor.a);
+    }
+    // Dimming
+    gl_FragColor = mix(color, dim_color, dim) * alpha;
+
+    if (!has_titlebar || gl_FragCoord.y - position.y > radius) {
+        vec2 corner_distance = min(gl_FragCoord.xy - position, size + position - gl_FragCoord.xy);
+        if (max(corner_distance.x, corner_distance.y) < radius) {
+            float d = radius - distance(corner_distance, vec2(radius));
+            float smooth = smoothstep(-1.0, 0.5, d);
+            gl_FragColor = mix(vec4(0), gl_FragColor, smooth);
+        }
+    }
+}