From 588ea8e290a61a8a98e72617fd679689891e2e39 Mon Sep 17 00:00:00 2001 From: William McKinnon Date: Wed, 18 Jan 2023 01:49:26 -0500 Subject: [PATCH] feat: Add box shadows (#64) Co-authored-by: Erik Reider <35975961+ErikReider@users.noreply.github.com> --- README.md | 7 +- config.in | 4 + include/sway/commands.h | 3 + include/sway/config.h | 3 + include/sway/desktop/fx_renderer.h | 16 ++++ include/sway/tree/container.h | 2 + sway/commands.c | 3 + sway/commands/shadow_blur_radius.c | 25 ++++++ sway/commands/shadow_color.c | 25 ++++++ sway/commands/shadows.c | 31 ++++++++ sway/config.c | 3 + sway/desktop/fx_renderer.c | 109 ++++++++++++++++++++++++++- sway/desktop/output.c | 9 ++- sway/desktop/render.c | 60 ++++++++++++++- sway/desktop/shaders/box_shadow.frag | 74 ++++++++++++++++++ sway/desktop/shaders/meson.build | 1 + sway/desktop/shaders/quad_round.frag | 10 ++- sway/meson.build | 4 + sway/sway.5.scd | 11 +++ sway/tree/container.c | 1 + 20 files changed, 388 insertions(+), 13 deletions(-) create mode 100644 sway/commands/shadow_blur_radius.c create mode 100644 sway/commands/shadow_color.c create mode 100644 sway/commands/shadows.c create mode 100644 sway/desktop/shaders/box_shadow.frag diff --git a/README.md b/README.md index 5e9016e6..159db607 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,11 @@ Sway is an incredible window manager, and certainly one of the most well establi + Corner radius: `corner_radius ` + Application saturation: `for_window [CRITERIA HERE] saturation 2.0>` -+ Dim unfocused windows: ++ Window shadows: + - `shadows on|off` + - `shadow_blur_radius ` + - `shadow_color ex, #0000007F` ++ Dim unfocused windows: - `dim_inactive ` - `dim_inactive_colors.unfocused ex, #000000FF` - `dim_inactive_colors.urgent ex, #900000FF` @@ -22,7 +26,6 @@ Sway is an incredible window manager, and certainly one of the most well establi + fade in / out animations + window movement animations -+ drop shadows + blur ## Installation diff --git a/config.in b/config.in index bcc89de2..174b48f9 100644 --- a/config.in +++ b/config.in @@ -24,6 +24,10 @@ set $menu dmenu_path | dmenu | xargs swaymsg exec -- # window corner radius in px corner_radius 10 +shadows off +shadow_blur_radius 20 +shadow_color #0000007F + # inactive window fade amount. 0.0 = no dimming, 1.0 = fully dimmed dim_inactive 0.0 dim_inactive_colors.unfocused #000000FF diff --git a/include/sway/commands.h b/include/sway/commands.h index 98b232e1..256b3506 100644 --- a/include/sway/commands.h +++ b/include/sway/commands.h @@ -178,6 +178,9 @@ sway_cmd cmd_scratchpad; sway_cmd cmd_seamless_mouse; sway_cmd cmd_set; sway_cmd cmd_shortcuts_inhibitor; +sway_cmd cmd_shadow_blur_radius; +sway_cmd cmd_shadow_color; +sway_cmd cmd_shadows; sway_cmd cmd_show_marks; sway_cmd cmd_smart_borders; sway_cmd cmd_smart_gaps; diff --git a/include/sway/config.h b/include/sway/config.h index 55aa8fbe..bcb06f0f 100644 --- a/include/sway/config.h +++ b/include/sway/config.h @@ -482,6 +482,9 @@ struct sway_config { float unfocused[4]; float urgent[4]; } dim_inactive_colors; + bool shadow_enabled; + int shadow_blur_sigma; + float shadow_color[4]; char *swaynag_command; struct swaynag_instance swaynag_config_errors; diff --git a/include/sway/desktop/fx_renderer.h b/include/sway/desktop/fx_renderer.h index c5bae260..1c3121cd 100644 --- a/include/sway/desktop/fx_renderer.h +++ b/include/sway/desktop/fx_renderer.h @@ -47,6 +47,8 @@ struct fx_renderer { float projection[9]; + GLuint stencil_buffer_id; + struct { bool OES_egl_image_external; } exts; @@ -84,6 +86,17 @@ struct fx_renderer { GLint half_thickness; } corner; + struct { + GLuint program; + GLint proj; + GLint color; + GLint pos_attrib; + GLint position; + GLint size; + GLint blur_sigma; + GLint corner_radius; + } box_shadow; + struct gles2_tex_shader tex_rgba; struct gles2_tex_shader tex_rgbx; struct gles2_tex_shader tex_ext; @@ -118,4 +131,7 @@ void fx_render_border_corner(struct fx_renderer *renderer, const struct wlr_box const float color[static 4], const float projection[static 9], enum corner_location corner_location, int radius, int border_thickness); +void fx_render_box_shadow(struct fx_renderer *renderer, const struct wlr_box *box, + const float color[static 4], const float projection[static 9], int radius, float blur_sigma); + #endif diff --git a/include/sway/tree/container.h b/include/sway/tree/container.h index 75a8113a..91448ac7 100644 --- a/include/sway/tree/container.h +++ b/include/sway/tree/container.h @@ -113,6 +113,8 @@ struct sway_container { // Hidden scratchpad containers have a NULL parent. bool scratchpad; + bool shadow_enabled; + float saturation; float alpha; diff --git a/sway/commands.c b/sway/commands.c index 6e473b97..9bd5275d 100644 --- a/sway/commands.c +++ b/sway/commands.c @@ -88,6 +88,9 @@ static const struct cmd_handler handlers[] = { { "popup_during_fullscreen", cmd_popup_during_fullscreen }, { "seat", cmd_seat }, { "set", cmd_set }, + { "shadow_blur_radius", cmd_shadow_blur_radius }, + { "shadow_color", cmd_shadow_color }, + { "shadows", cmd_shadows }, { "show_marks", cmd_show_marks }, { "smart_borders", cmd_smart_borders }, { "smart_gaps", cmd_smart_gaps }, diff --git a/sway/commands/shadow_blur_radius.c b/sway/commands/shadow_blur_radius.c new file mode 100644 index 00000000..036341f8 --- /dev/null +++ b/sway/commands/shadow_blur_radius.c @@ -0,0 +1,25 @@ +#include +#include "sway/commands.h" +#include "sway/config.h" +#include "sway/tree/arrange.h" +#include "sway/tree/container.h" +#include "log.h" + +struct cmd_results *cmd_shadow_blur_radius(int argc, char **argv) { + struct cmd_results *error = NULL; + if ((error = checkarg(argc, "shadow_blur_radius", EXPECTED_EQUAL_TO, 1))) { + return error; + } + + char *inv; + int value = strtol(argv[0], &inv, 10); + if (*inv != '\0' || value < 0 || value > 99) { + return cmd_results_new(CMD_FAILURE, "Invalid size specified"); + } + + config->shadow_blur_sigma = value; + + arrange_root(); + + return cmd_results_new(CMD_SUCCESS, NULL); +} diff --git a/sway/commands/shadow_color.c b/sway/commands/shadow_color.c new file mode 100644 index 00000000..02952bdd --- /dev/null +++ b/sway/commands/shadow_color.c @@ -0,0 +1,25 @@ +#include "log.h" +#include "sway/commands.h" +#include "sway/config.h" +#include "sway/output.h" +#include "sway/tree/arrange.h" +#include "sway/tree/container.h" +#include "util.h" + +struct cmd_results *cmd_shadow_color(int argc, char **argv) { + struct cmd_results *error = NULL; + if ((error = checkarg(argc, "shadow_color", EXPECTED_AT_LEAST, 1))) { + return error; + } + + uint32_t color; + if (!parse_color(argv[0], &color)) { + return cmd_results_new(CMD_INVALID, "Invalid %s color %s", + "shadow_color", argv[0]); + } + color_to_rgba(config->shadow_color, color); + + arrange_root(); + + return cmd_results_new(CMD_SUCCESS, NULL); +} diff --git a/sway/commands/shadows.c b/sway/commands/shadows.c new file mode 100644 index 00000000..2b57b2e6 --- /dev/null +++ b/sway/commands/shadows.c @@ -0,0 +1,31 @@ +#include +#include "sway/commands.h" +#include "sway/config.h" +#include "sway/tree/arrange.h" +#include "sway/tree/view.h" +#include "sway/tree/container.h" +#include "log.h" +#include "stringop.h" +#include "util.h" + +struct cmd_results *cmd_shadows(int argc, char **argv) { + struct cmd_results *error = checkarg(argc, "shadows", EXPECTED_AT_LEAST, 1); + + if (error) { + return error; + } + + struct sway_container *con = config->handler_context.container; + + bool result = parse_boolean(argv[0], config->shadow_enabled); + if (con == NULL) { + config->shadow_enabled = result; + } else { + con->shadow_enabled = result; + container_damage_whole(con); + } + + arrange_root(); + + return cmd_results_new(CMD_SUCCESS, NULL); +} diff --git a/sway/config.c b/sway/config.c index e99a3458..e965601b 100644 --- a/sway/config.c +++ b/sway/config.c @@ -338,6 +338,9 @@ static void config_defaults(struct sway_config *config) { config->dim_inactive = 0.0f; color_to_rgba(config->dim_inactive_colors.unfocused, 0x000000FF); color_to_rgba(config->dim_inactive_colors.urgent, 0x900000FF); + config->shadow_enabled = false; + config->shadow_blur_sigma = 20.0f; + color_to_rgba(config->shadow_color, 0x0000007F); // The keysym to keycode translation struct xkb_rule_names rules = {0}; diff --git a/sway/desktop/fx_renderer.c b/sway/desktop/fx_renderer.c index 782ceb88..03645b0f 100644 --- a/sway/desktop/fx_renderer.c +++ b/sway/desktop/fx_renderer.c @@ -24,6 +24,7 @@ #include "quad_round_tl_frag_src.h" #include "quad_round_tr_frag_src.h" #include "corner_frag_src.h" +#include "box_shadow_frag_src.h" #include "tex_rgba_frag_src.h" #include "tex_rgbx_frag_src.h" #include "tex_external_frag_src.h" @@ -108,6 +109,7 @@ static GLuint compile_shader(GLuint type, const GLchar *src) { GLint ok; glGetShaderiv(shader, GL_COMPILE_STATUS, &ok); if (ok == GL_FALSE) { + sway_log(SWAY_ERROR, "Failed to compile shader"); glDeleteShader(shader); shader = 0; } @@ -140,6 +142,7 @@ static GLuint link_program(const GLchar *vert_src, const GLchar *frag_src) { GLint ok; glGetProgramiv(prog, GL_LINK_STATUS, &ok); if (ok == GL_FALSE) { + sway_log(SWAY_ERROR, "Failed to link shader"); glDeleteProgram(prog); goto error; } @@ -294,6 +297,20 @@ struct fx_renderer *fx_renderer_create(struct wlr_egl *egl) { renderer->shaders.corner.half_size = glGetUniformLocation(prog, "half_size"); renderer->shaders.corner.half_thickness = glGetUniformLocation(prog, "half_thickness"); + // box shadow shader + prog = link_program(common_vert_src, box_shadow_frag_src); + renderer->shaders.box_shadow.program = prog; + if (!renderer->shaders.box_shadow.program) { + goto error; + } + renderer->shaders.box_shadow.proj = glGetUniformLocation(prog, "proj"); + renderer->shaders.box_shadow.color = glGetUniformLocation(prog, "color"); + renderer->shaders.box_shadow.pos_attrib = glGetAttribLocation(prog, "pos"); + renderer->shaders.box_shadow.position = glGetUniformLocation(prog, "position"); + renderer->shaders.box_shadow.size = glGetUniformLocation(prog, "size"); + renderer->shaders.box_shadow.blur_sigma = glGetUniformLocation(prog, "blur_sigma"); + renderer->shaders.box_shadow.corner_radius = glGetUniformLocation(prog, "corner_radius"); + // fragment shaders prog = link_program(common_vert_src, tex_rgba_frag_src); if (!init_frag_shader(&renderer->shaders.tex_rgba, prog)) { @@ -323,6 +340,7 @@ error: glDeleteProgram(renderer->shaders.rounded_tl_quad.program); glDeleteProgram(renderer->shaders.rounded_tr_quad.program); glDeleteProgram(renderer->shaders.corner.program); + glDeleteProgram(renderer->shaders.box_shadow.program); glDeleteProgram(renderer->shaders.tex_rgba.program); glDeleteProgram(renderer->shaders.tex_rgbx.program); glDeleteProgram(renderer->shaders.tex_ext.program); @@ -340,6 +358,15 @@ error: } void fx_renderer_begin(struct fx_renderer *renderer, uint32_t width, uint32_t height) { + // Create and render the stencil buffer + if (renderer->stencil_buffer_id == 0) { + glGenRenderbuffers(1, &renderer->stencil_buffer_id); + } + glBindRenderbuffer(GL_RENDERBUFFER, renderer->stencil_buffer_id); + glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, width, height); + glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, + GL_RENDERBUFFER, renderer->stencil_buffer_id); + glViewport(0, 0, width, height); // refresh projection matrix @@ -354,8 +381,9 @@ void fx_renderer_end() { } void fx_renderer_clear(const float color[static 4]) { - glClearColor(color[0], color[1], color[2], color[3]); - glClear(GL_COLOR_BUFFER_BIT); + glClearColor(color[0], color[1], color[2], color[3]); + glClearStencil(0); + glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); } void fx_renderer_scissor(struct wlr_box *box) { @@ -616,3 +644,80 @@ void fx_render_border_corner(struct fx_renderer *renderer, const struct wlr_box glDisableVertexAttribArray(renderer->shaders.corner.pos_attrib); } + +// TODO: alpha input arg? +void fx_render_box_shadow(struct fx_renderer *renderer, const struct wlr_box *box, + const float color[static 4], const float projection[static 9], + int corner_radius, float blur_sigma) { + if (box->width == 0 || box->height == 0) { + return; + } + assert(box->width > 0 && box->height > 0); + float matrix[9]; + wlr_matrix_project_box(matrix, box, WL_OUTPUT_TRANSFORM_NORMAL, 0, projection); + + float gl_matrix[9]; + wlr_matrix_multiply(gl_matrix, renderer->projection, matrix); + + // TODO: investigate why matrix is flipped prior to this cmd + // wlr_matrix_multiply(gl_matrix, flip_180, gl_matrix); + + wlr_matrix_transpose(gl_matrix, gl_matrix); + + // Init stencil work + // NOTE: Alpha needs to be set to 1.0 to be able to discard any "empty" pixels + const float col[4] = {0.0, 0.0, 0.0, 1.0}; + struct wlr_box inner_box; + memcpy(&inner_box, box, sizeof(struct wlr_box)); + inner_box.x += blur_sigma; + inner_box.y += blur_sigma; + inner_box.width -= blur_sigma * 2; + inner_box.height -= blur_sigma * 2; + + glEnable(GL_STENCIL_TEST); + glClearStencil(0); + glClear(GL_STENCIL_BUFFER_BIT); + + glStencilFunc(GL_ALWAYS, 1, 0xFF); + glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); + // Disable writing to color buffer + glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); + // Draw the rounded rect as a mask + fx_render_rounded_rect(renderer, &inner_box, col, projection, corner_radius, ALL); + // Close the mask + glStencilFunc(GL_NOTEQUAL, 1, 0xFF); + glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); + // Reenable writing to color buffer + glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + + // blending will practically always be needed (unless we have a madman + // who uses opaque shadows with zero sigma), so just enable it + glEnable(GL_BLEND); + + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + glUseProgram(renderer->shaders.box_shadow.program); + + glUniformMatrix3fv(renderer->shaders.box_shadow.proj, 1, GL_FALSE, gl_matrix); + glUniform4f(renderer->shaders.box_shadow.color, color[0], color[1], color[2], color[3]); + glUniform1f(renderer->shaders.box_shadow.blur_sigma, blur_sigma); + glUniform1f(renderer->shaders.box_shadow.corner_radius, corner_radius); + + glUniform2f(renderer->shaders.box_shadow.size, box->width, box->height); + glUniform2f(renderer->shaders.box_shadow.position, box->x, box->y); + + glVertexAttribPointer(renderer->shaders.box_shadow.pos_attrib, 2, GL_FLOAT, GL_FALSE, + 0, verts); + + glEnableVertexAttribArray(renderer->shaders.box_shadow.pos_attrib); + + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); + + glDisableVertexAttribArray(renderer->shaders.box_shadow.pos_attrib); + + glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); + + glClearStencil(0); + glClear(GL_STENCIL_BUFFER_BIT); + glDisable(GL_STENCIL_TEST); +} diff --git a/sway/desktop/output.c b/sway/desktop/output.c index 182ca428..abf60a2f 100644 --- a/sway/desktop/output.c +++ b/sway/desktop/output.c @@ -746,11 +746,12 @@ static void damage_child_views_iterator(struct sway_container *con, void output_damage_whole_container(struct sway_output *output, struct sway_container *con) { // Pad the box by 1px, because the width is a double and might be a fraction + int shadow_sigma = con->shadow_enabled ? config->shadow_blur_sigma : 0; struct wlr_box box = { - .x = con->current.x - output->lx - 1, - .y = con->current.y - output->ly - 1, - .width = con->current.width + 2, - .height = con->current.height + 2, + .x = con->current.x - output->lx - 1 - shadow_sigma, + .y = con->current.y - output->ly - 1 - shadow_sigma, + .width = con->current.width + 2 + shadow_sigma * 2, + .height = con->current.height + 2 + shadow_sigma * 2, }; scale_box(&box, output->wlr_output->scale); if (wlr_damage_ring_add_box(&output->damage_ring, &box)) { diff --git a/sway/desktop/render.c b/sway/desktop/render.c index 35e2150e..36be155e 100644 --- a/sway/desktop/render.c +++ b/sway/desktop/render.c @@ -328,6 +328,47 @@ damage_finish: pixman_region32_fini(&damage); } +// _box.x and .y are expected to be layout-local +// _box.width and .height are expected to be output-buffer-local +void render_box_shadow(struct sway_output *output, pixman_region32_t *output_damage, + const struct wlr_box *_box, const float color[static 4], + float blur_sigma, float corner_radius, float border_thickness) { + struct wlr_output *wlr_output = output->wlr_output; + struct fx_renderer *renderer = output->server->renderer; + + struct wlr_box box; + memcpy(&box, _box, sizeof(struct wlr_box)); + box.x -= output->lx * wlr_output->scale + blur_sigma; + box.y -= output->ly * wlr_output->scale + blur_sigma; + box.width += 2 * blur_sigma; + box.height += 2 * blur_sigma; + + // Uses the outer radii of the window for a more realistic look + corner_radius = corner_radius + border_thickness; + + pixman_region32_t damage; + pixman_region32_init(&damage); + pixman_region32_union_rect(&damage, &damage, box.x, box.y, + box.width, box.height); + pixman_region32_intersect(&damage, &damage, output_damage); + bool damaged = pixman_region32_not_empty(&damage); + if (!damaged) { + goto damage_finish; + } + + int nrects; + pixman_box32_t *rects = pixman_region32_rectangles(&damage, &nrects); + for (int i = 0; i < nrects; ++i) { + scissor_output(wlr_output, &rects[i]); + + fx_render_box_shadow(renderer, &box, color, + wlr_output->transform_matrix, corner_radius, blur_sigma); + } + +damage_finish: + pixman_region32_fini(&damage); +} + void premultiply_alpha(float color[4], float opacity) { color[3] *= opacity; color[0] *= color[3]; @@ -431,7 +472,7 @@ static void render_saved_view(struct sway_view *view, struct sway_output *output } /** - * Render a view's surface and left/bottom/right borders. + * Render a view's surface, shadow, and left/bottom/right borders. */ static void render_view(struct sway_output *output, pixman_region32_t *damage, struct sway_container *con, struct border_colors *colors, @@ -443,7 +484,22 @@ static void render_view(struct sway_output *output, pixman_region32_t *damage, render_view_toplevels(view, output, damage, deco_data); } - if (con->current.border == B_NONE || con->current.border == B_CSD) { + // if CSD borders, don't render borders or shadow + if (con->current.border == B_CSD) { + return; + } + + // render shadow + if (con->shadow_enabled && config->shadow_blur_sigma > 0 && config->shadow_color[3] > 0.0) { + struct sway_container_state *state = &con->current; + struct wlr_box box = { state->x, state->y, state->width, state->height }; + scale_box(&box, output->wlr_output->scale); + render_box_shadow(output, damage, &box, config->shadow_color, + config->shadow_blur_sigma, con->corner_radius, + state->border_thickness); + } + + if (con->current.border == B_NONE) { return; } diff --git a/sway/desktop/shaders/box_shadow.frag b/sway/desktop/shaders/box_shadow.frag new file mode 100644 index 00000000..c9b2b91f --- /dev/null +++ b/sway/desktop/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/shaders/meson.build b/sway/desktop/shaders/meson.build index 08efb967..ce2439de 100644 --- a/sway/desktop/shaders/meson.build +++ b/sway/desktop/shaders/meson.build @@ -7,6 +7,7 @@ shaders = [ 'quad_round_tl.frag', 'quad_round_tr.frag', 'corner.frag', + 'box_shadow.frag', 'tex_rgba.frag', 'tex_rgbx.frag', 'tex_external.frag', diff --git a/sway/desktop/shaders/quad_round.frag b/sway/desktop/shaders/quad_round.frag index e347284b..ddd6fe9b 100644 --- a/sway/desktop/shaders/quad_round.frag +++ b/sway/desktop/shaders/quad_round.frag @@ -7,9 +7,13 @@ uniform vec2 position; uniform float radius; void main() { - vec2 half_size = size / 2.0; + vec2 half_size = size * 0.5; vec2 q = abs(gl_FragCoord.xy - position - half_size) - half_size + radius; - float distance = min(max(q.x,q.y),0.0) + length(max(q,0.0)) - radius; - float smoothedAlpha = 1.0 - smoothstep(-1.0, 1.0, distance); + 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/meson.build b/sway/meson.build index 12362fcd..757d0c99 100644 --- a/sway/meson.build +++ b/sway/meson.build @@ -106,6 +106,9 @@ sway_sources = files( 'commands/seat/shortcuts_inhibitor.c', 'commands/seat/xcursor_theme.c', 'commands/set.c', + 'commands/shadow_blur_radius.c', + 'commands/shadow_color.c', + 'commands/shadows.c', 'commands/show_marks.c', 'commands/shortcuts_inhibitor.c', 'commands/smart_borders.c', @@ -250,3 +253,4 @@ executable( link_with: [lib_sway_common], install: true ) + diff --git a/sway/sway.5.scd b/sway/sway.5.scd index 15e60844..a5fb4173 100644 --- a/sway/sway.5.scd +++ b/sway/sway.5.scd @@ -659,6 +659,17 @@ The default colors are: *dim_inactive_colors.urgent* The color to dim inactive urgent windows with. Example color: #900000FF +*shadows* + Adjusts if shadows should be enabled or not (on|off). Can also be set per + window with *for_window*. + +*shadow_blur_radius* + Adjusts the shadow blur radius of windows between 0 (disabled) and 100 + while 20 is the default value. + +*shadow_color* + The shadow color. Default color: #0000007F + *default_border* normal|none|pixel [] Set default border style for new tiled windows. diff --git a/sway/tree/container.c b/sway/tree/container.c index 29a1e226..9de6c551 100644 --- a/sway/tree/container.c +++ b/sway/tree/container.c @@ -42,6 +42,7 @@ struct sway_container *container_create(struct sway_view *view) { c->view = view; c->alpha = 1.0f; c->saturation = 1.0f; + c->shadow_enabled = config->shadow_enabled; c->corner_radius = config->corner_radius; if (!view) {