Render drop shadow for active window

Add the twin_stack_blur() function to implement Mario's Stack Blur
algorithm, which blurs the target pixel map. Additionally, create a test
window to evaluate the effect of twin_stack_blur(). Implement the
twin_drop_shadow() function to handle the pixels within the drop shadow
area of the active window's pixel map. The drop shadow effect of the
window is only visible when the window is on the top layer, ensuring the
active window stands out visually.

Implement the twin_shadow_border() function to create a darker border of
the active window that gives a more dimensional appearance.

In the twin_drop_shadow() function, twin_stack_blur() will apply a blur
effect to the pixels beneath the active window's pixel map, which aims
to create a frosted glass appearance.

Furthermore, implement the twin_cover() function to cover the target
pixels with the desired color.

Ref: https://melatonin.dev/blog/implementing-marios-stack-blur-15-times-in-cpp/
Close sysprog21#34

Signed-off-by: Wei-Hsin Yeh <weihsinyeh168@gmail.com>

Author: weihsinyeh

apps/multi.c

@@ -7,6 +7,7 @@
 #include "apps_multi.h"
 
 #define D(x) twin_double_to_fixed(x)
+#define ASSET_PATH "assets/"
 
 static void apps_line_start(twin_screen_t *screen, int x, int y, int w, int h)
 {
@@ -272,6 +273,47 @@ static void apps_flower_start(twin_screen_t *screen, int x, int y, int w, int h)
     twin_window_show(window);
 }
 
+static void apps_test(twin_screen_t *screen, int x, int y, int w, int h)
+{
+    twin_pixmap_t *raw_background =
+        twin_pixmap_from_file(ASSET_PATH "tux.png", TWIN_ARGB32);
+    twin_window_t *window = twin_window_create(
+        screen, TWIN_ARGB32, TwinWindowApplication, x, y, w, h);
+    twin_window_set_name(window, "Test");
+    twin_pixmap_t *scaled_background = twin_pixmap_create(
+        TWIN_ARGB32, window->pixmap->width, window->pixmap->height);
+    twin_fixed_t sx, sy;
+    sx = twin_fixed_div(
+        twin_int_to_fixed(raw_background->width),
+        twin_int_to_fixed(window->client.right - window->client.left));
+    sy = twin_fixed_div(
+        twin_int_to_fixed(raw_background->height),
+        twin_int_to_fixed(window->client.bottom - window->client.top));
+
+    twin_matrix_scale(&raw_background->transform, sx, sy);
+    twin_operand_t srcop = {
+        .source_kind = TWIN_PIXMAP,
+        .u.pixmap = raw_background,
+    };
+
+    twin_composite(scaled_background, 0, 0, &srcop, 0, 0, 0, 0, 0, TWIN_SOURCE,
+                   screen->width, screen->height);
+
+    twin_pointer_t src, dst;
+    for (int y = window->client.top; y < window->client.bottom; y++)
+        for (int x = window->client.left; x < window->client.right; x++) {
+            src =
+                twin_pixmap_pointer(scaled_background, x - window->client.left,
+                                    y - window->client.top);
+            dst = twin_pixmap_pointer(window->pixmap, x, y);
+            *dst.argb32 = *src.argb32 | 0xff000000;
+        }
+
+    twin_pixmap_destroy(scaled_background);
+    twin_pixmap_destroy(raw_background);
+    twin_window_show(window);
+}
+
 void apps_multi_start(twin_screen_t *screen,
                       const char *name,
                       int x,
@@ -286,4 +328,5 @@ void apps_multi_start(twin_screen_t *screen,
     apps_ascii_start(screen, x += 20, y += 20, w, h);
     apps_jelly_start(screen, x += 20, y += 20, w / 2, h);
     apps_flower_start(screen, x += 20, y += 20, w, h);
+    apps_test(screen, x += 20, y += 20, w, h);
 }

configs/Kconfig

@@ -55,6 +55,10 @@ config CURSOR
     default n
     depends on !BACKEND_VNC
 
+config DROP_SHADOW
+    bool "Render drop shadow for active window"
+    default y
+
 endmenu
 
 menu "Image Loaders"

include/twin.h

@@ -194,6 +194,12 @@ typedef struct _twin_pixmap {
      * Pixels
      */
     twin_animation_t *animation;
+    /*
+     * When the pixel map is within the active window, it will have a drop
+     * shadow to enhance its visual distinction.
+     */
+    bool shadow;
+
     twin_pointer_t p;
     /*
      * When representing a window, this point
@@ -422,6 +428,11 @@ typedef void (*twin_destroy_func_t)(twin_window_t *window);
 struct _twin_window {
     twin_screen_t *screen;
     twin_pixmap_t *pixmap;
+
+    /* Set the shadow range for horizontal and vertical directions. */
+    twin_coord_t shadow_offset_x;
+    twin_coord_t shadow_offset_y;
+
     twin_window_style_t style;
     twin_rect_t client;
     twin_rect_t damage;
@@ -626,6 +637,15 @@ void twin_dispatch(twin_context_t *ctx);
  * draw.c
  */
 
+void twin_stack_blur(twin_pixmap_t *px,
+                     int radius,
+                     twin_coord_t left,
+                     twin_coord_t right,
+                     twin_coord_t top,
+                     twin_coord_t bottom);
+
+void twin_shadow_border(twin_pixmap_t *shadow);
+
 void twin_composite(twin_pixmap_t *dst,
                     twin_coord_t dst_x,
                     twin_coord_t dst_y,
@@ -649,6 +669,12 @@ void twin_fill(twin_pixmap_t *dst,
 
 void twin_premultiply_alpha(twin_pixmap_t *px);
 
+void twin_cover(twin_pixmap_t *dst,
+                twin_argb32_t color,
+                twin_coord_t x,
+                twin_coord_t y,
+                twin_coord_t width);
+
 /*
  * event.c
  */

include/twin_private.h

@@ -187,6 +187,21 @@ typedef int64_t twin_xfixed_t;
      ((((s) << 5) & 0xfc00) | (((s) >> 1) & 0x300)) | \
      ((((s) << 8) & 0xf80000) | (((s) << 3) & 0x70000)) | 0xff000000)
 
+#define min(x, y)            \
+    ({                       \
+        typeof(x) _x = (x);  \
+        typeof(y) _y = (y);  \
+        (void) (&_x == &_y); \
+        _x < _y ? _x : _y;   \
+    })
+#define max(x, y)            \
+    ({                       \
+        typeof(x) _x = (x);  \
+        typeof(y) _y = (y);  \
+        (void) (&_x == &_y); \
+        _x > _y ? _x : _y;   \
+    })
+
 typedef union {
     twin_pointer_t p;
     twin_argb32_t c;

src/draw-pixman.c

@@ -7,6 +7,8 @@
 #include <pixman.h>
 #include "twin_private.h"
 
+#define TWIN_TITLE_HEIGHT 20
+
 static void twin_argb32_to_pixman_color(twin_argb32_t argb,
                                         pixman_color_t *color)
 {
@@ -61,6 +63,219 @@ static void pixmap_matrix_scale(pixman_image_t *src, twin_matrix_t *matrix)
     pixman_image_set_transform(src, &transform);
 }
 
+#define _twin_add_ARGB(s, d, i, t) (((t) = (s) + twin_get_8(d, i)))
+#define _twin_add(s, d, t) (((t) = (s) + (d)))
+#define _twin_div(d, den, i, t)                     \
+    (((t) = (d) / (den)), (t) = twin_get_8((t), 0), \
+     (twin_argb32_t) twin_sat(t) << (i))
+#define _twin_sub_ARGB(s, d, i, t) (((t) = (s) - twin_get_8(d, i)))
+#define _twin_sub(s, d, t) (((t) = (s) - (d)))
+#define twin_put_8(d, i, t) (((t) = (d) << (i)))
+
+void twin_stack(twin_pixmap_t *trg_px,
+                twin_pixmap_t *src_px,
+                int radius,
+                int first_str,
+                int first_end,
+                int second_str,
+                int second_end,
+                bool horiz_scan)
+{
+    int den = (radius + 1) * (radius + 1);
+    twin_pointer_t src_ptr, trg_ptr, old_ptr, new_ptr;
+    twin_argb32_t sumInR, sumOutR, sumR, sumInG, sumOutG, sumG, sumInB, sumOutB,
+        sumB, _cur, _old, _new, _src;
+    uint16_t t1, t2, t3;
+    for (int first = first_str; first < first_end; first++) {
+        sumInR = sumOutR = sumR = sumInG = sumOutG = sumG = sumInB = sumOutB =
+            sumB = 0x00000000;
+
+        /* Initialize SumOut by padding */
+        if (horiz_scan)
+            src_ptr = twin_pixmap_pointer(src_px, second_str, first);
+        else
+            src_ptr = twin_pixmap_pointer(src_px, first, second_str);
+        _src = *src_ptr.argb32;
+
+        for (int i = second_str; i < second_str + radius; i++) {
+            sumOutR = _twin_add_ARGB(sumOutR, _src, 0, t1);
+            sumOutG = _twin_add_ARGB(sumOutG, _src, 8, t2);
+            sumOutB = _twin_add_ARGB(sumOutB, _src, 16, t3);
+            for (int j = 0; j < (i - second_str) + 1; j++) {
+                sumR = _twin_add_ARGB(sumR, _src, 0, t1);
+                sumG = _twin_add_ARGB(sumG, _src, 8, t2);
+                sumB = _twin_add_ARGB(sumB, _src, 16, t3);
+            }
+        }
+
+        /* Initialize SumIn */
+        for (int i = second_str; i < second_str + radius; i++) {
+            if (horiz_scan)
+                src_ptr = twin_pixmap_pointer(src_px, i, first);
+            else
+                src_ptr = twin_pixmap_pointer(src_px, first, i);
+            _src = *src_ptr.argb32;
+            sumInR = _twin_add_ARGB(sumInR, _src, 0, t1);
+            sumInG = _twin_add_ARGB(sumInG, _src, 8, t2);
+            sumInB = _twin_add_ARGB(sumInB, _src, 16, t3);
+            for (int j = 0; j < radius - (i - second_str); j++) {
+                sumR = _twin_add_ARGB(sumR, _src, 0, t1);
+                sumG = _twin_add_ARGB(sumG, _src, 8, t2);
+                sumB = _twin_add_ARGB(sumB, _src, 16, t3);
+            }
+        }
+
+        for (int cur = second_str; cur < second_end; cur++) {
+            if (horiz_scan) {
+                src_ptr = twin_pixmap_pointer(src_px, cur, first);
+                trg_ptr = twin_pixmap_pointer(trg_px, cur, first);
+                old_ptr = twin_pixmap_pointer(
+                    src_px, max(cur - radius, second_str), first);
+                new_ptr = twin_pixmap_pointer(
+                    src_px, min(cur + radius, second_end - 1), first);
+            } else {
+                src_ptr = twin_pixmap_pointer(src_px, first, cur);
+                trg_ptr = twin_pixmap_pointer(trg_px, first, cur);
+                old_ptr = twin_pixmap_pointer(src_px, first,
+                                              max(cur - radius, second_str));
+                new_ptr = twin_pixmap_pointer(
+                    src_px, first, min(cur + radius, second_end - 1));
+            }
+            _cur = *src_ptr.argb32;
+            _old = *old_ptr.argb32;
+            _new = *new_ptr.argb32;
+            /* STEP 1 : sum_out + current */
+            sumOutR = _twin_add_ARGB(sumOutR, _cur, 0, t1);
+            sumOutG = _twin_add_ARGB(sumOutG, _cur, 8, t2);
+            sumOutB = _twin_add_ARGB(sumOutB, _cur, 16, t3);
+            /* STEP 2 : sum_in + new */
+            sumInR = _twin_add_ARGB(sumInR, _new, 0, t1);
+            sumInG = _twin_add_ARGB(sumInG, _new, 8, t2);
+            sumInB = _twin_add_ARGB(sumInB, _new, 16, t3);
+            /* STEP 3 : sum + sum_in */
+            sumR = _twin_add(sumR, sumInR, t1);
+            sumG = _twin_add(sumG, sumInG, t2);
+            sumB = _twin_add(sumB, sumInB, t3);
+            /* STEP 4 : sum / denominator */
+            *trg_ptr.argb32 =
+                (_twin_div(sumR, den, 0, t1) | _twin_div(sumG, den, 8, t2) |
+                 _twin_div(sumB, den, 16, t3) | (*src_ptr.argb32 & 0xff000000));
+            /* STEP 5 : sum - sum_out */
+            sumR = _twin_sub(sumR, sumOutR, t1);
+            sumG = _twin_sub(sumG, sumOutG, t2);
+            sumB = _twin_sub(sumB, sumOutB, t3);
+            /* STEP 6 : sum_out - old */
+            sumOutR = _twin_sub_ARGB(sumOutR, _old, 0, t1);
+            sumOutG = _twin_sub_ARGB(sumOutG, _old, 8, t2);
+            sumOutB = _twin_sub_ARGB(sumOutB, _old, 16, t3);
+            /* STEP 7 : sum_in - current */
+            sumInR = _twin_sub_ARGB(sumInR, _cur, 0, t1);
+            sumInG = _twin_sub_ARGB(sumInG, _cur, 8, t2);
+            sumInB = _twin_sub_ARGB(sumInB, _cur, 16, t3);
+        }
+    }
+}
+
+void twin_stack_blur(twin_pixmap_t *px,
+                     int radius,
+                     twin_coord_t left,
+                     twin_coord_t right,
+                     twin_coord_t top,
+                     twin_coord_t bottom)
+{
+    if (px->format != TWIN_ARGB32)
+        return;
+    twin_pixmap_t *tmp_px =
+        twin_pixmap_create(px->format, px->width, px->height);
+    memcpy(tmp_px->p.v, px->p.v,
+           px->width * px->height * twin_bytes_per_pixel(px->format));
+    /*
+     * Originally, performing a 2D convolution on each pixel takes O(width *
+     * height * k²). However, by first scanning horizontally and then vertically
+     * across the pixel map, and applying a 1D convolution to each pixel, the
+     * complexity is reduced to O(2 * width * height * k).
+     */
+    twin_stack(tmp_px, px, radius, top, bottom, left, right, true);
+    twin_stack(px, tmp_px, radius, left, right, top, bottom, false);
+    twin_pixmap_destroy(tmp_px);
+    return;
+}
+
+void twin_shadow_border(twin_pixmap_t *shadow)
+{
+    twin_coord_t right_edge =
+                     (*shadow).width - (*shadow).window->shadow_offset_x,
+                 bottom_edge =
+                     (*shadow).height - (*shadow).window->shadow_offset_y,
+                 right_span = right_edge, clip, stride = 2, corner_offset,
+                 offset = min((*shadow).window->shadow_offset_x,
+                              (*shadow).window->shadow_offset_y);
+    twin_pointer_t dst;
+    twin_source_u src;
+    twin_argb32_t color_x,
+        color_y = 0xff000000,
+        color_shift = ((((twin_coord_t) (0xff)) / (offset >> 2))) << 24;
+
+    for (twin_coord_t y = TWIN_TITLE_HEIGHT; y < (*shadow).height; y++) {
+        color_x = 0xff000000;
+        /* Render the right edge of the shadow border. */
+        if (y < bottom_edge) {
+            /*
+             * Create a shadow with a diagonal shape, extending from the
+             * top-left to the bottom-right.
+             */
+            clip = max(
+                0, shadow->window->shadow_offset_x - (y - TWIN_TITLE_HEIGHT));
+            for (twin_coord_t x = right_edge; x < (*shadow).width - clip; x++) {
+                dst = twin_pixmap_pointer(shadow, x, y);
+                src.c = color_x;
+                _twin_c_over_argb32(dst, src, 1);
+                if ((x - right_edge) % stride == 0) {
+                    if (color_x > color_shift)
+                        color_x -= color_shift;
+                    color_x &= 0xff000000;
+                }
+            }
+        } else
+            /* Calculate the range of the corner. */
+            right_span++;
+
+        /* Render the bottom edge of the shadow border. */
+        if (y > bottom_edge) {
+            /*
+             * Create a shadow with a diagonal shape, extending from the
+             * top-left to the bottom-right.
+             */
+            clip = max(0, y - bottom_edge);
+            dst = twin_pixmap_pointer(shadow, clip, y);
+            src.c = color_y;
+            _twin_c_over_argb32(dst, src, right_edge - clip);
+
+            /* Render the bottom-right corner of the shadow border. */
+
+            /*
+             * Handle the case where the vertical shadow offset is larger than
+             * the horizontal shadow offset.
+             */
+            corner_offset = min(right_span - right_edge, offset);
+
+            for (twin_coord_t i = 0; i < corner_offset; i++) {
+                /* The corner's pixels are symmetrical to the diagonal. */
+                dst = twin_pixmap_pointer(shadow, right_edge + i, y);
+                _twin_c_over_argb32(dst, src, 1);
+                dst = twin_pixmap_pointer(
+                    shadow, right_edge + (y - bottom_edge), bottom_edge + i);
+                _twin_c_over_argb32(dst, src, 1);
+            }
+            if ((shadow->y + y - bottom_edge) % stride == 0) {
+                if (color_y > color_shift)
+                    color_y -= color_shift;
+                color_y &= 0xff000000;
+            }
+        }
+    }
+}
+
 void twin_composite(twin_pixmap_t *_dst,
                     twin_coord_t dst_x,
                     twin_coord_t dst_y,
@@ -190,3 +405,16 @@ void twin_premultiply_alpha(twin_pixmap_t *px)
             p.argb32[x] = _twin_apply_alpha(p.argb32[x]);
     }
 }
+
+void twin_cover(twin_pixmap_t *dst,
+                twin_argb32_t color,
+                twin_coord_t x,
+                twin_coord_t y,
+                twin_coord_t width)
+{
+    twin_pointer_t pt;
+    for (twin_coord_t i = 0; i < width; i++) {
+        pt = twin_pixmap_pointer(dst, x + i, y);
+        *pt.argb32 = color;
+    }
+}