From 6f6991a1b38b03e87fd3f73607ca2393ae62cfea Mon Sep 17 00:00:00 2001 From: William McKinnon Date: Wed, 6 Sep 2023 00:32:08 -0400 Subject: [PATCH] refactor: simplify blur (#219) * refactor: removed surface_width + surface_height from render_blur() * Fixed scaling issues * Minor refactors * removed scaled_dst box * removed uneeded fb bind * removed unneeded src_box * removed unneeded wlr_fbox_from_box function * removed src_box * Don't scale the blur translucent region twice * Renamed extended_damage to original_damage to reflect better what it actually is * Removed unneeded clearing of the wlr fbo before rendering onto it * Removed the need for our own main FBO, also fixes some damage bugs * Simplified detection of blur on workspace * cleaned up comments --------- Co-authored-by: Erik Reider <35975961+ErikReider@users.noreply.github.com> --- .../sway/desktop/fx_renderer/fx_renderer.h | 24 ++- include/sway/tree/workspace.h | 3 +- sway/desktop/fx_renderer/fx_framebuffer.c | 10 +- sway/desktop/fx_renderer/fx_renderer.c | 41 ++-- sway/desktop/output.c | 32 +-- sway/desktop/render.c | 183 ++++++++---------- sway/tree/workspace.c | 39 ++-- 7 files changed, 156 insertions(+), 176 deletions(-) diff --git a/include/sway/desktop/fx_renderer/fx_renderer.h b/include/sway/desktop/fx_renderer/fx_renderer.h index 4a60a7ea..67dc6adf 100644 --- a/include/sway/desktop/fx_renderer/fx_renderer.h +++ b/include/sway/desktop/fx_renderer/fx_renderer.h @@ -120,12 +120,22 @@ struct fx_renderer { int viewport_width, viewport_height; - struct fx_framebuffer wlr_buffer; // Just the framebuffer used by wlroots - struct fx_framebuffer main_buffer; // The main FB used for rendering - struct fx_framebuffer blur_buffer; // Contains the blurred background for tiled windows + struct wlr_output *wlr_output; + + // The framebuffer used by wlroots + struct fx_framebuffer wlr_buffer; + // Contains the blurred background for tiled windows + struct fx_framebuffer blur_buffer; + // Contains the original pixels to draw over the areas where artifact are visible + struct fx_framebuffer blur_saved_pixels_buffer; // Blur swaps between the two effects buffers everytime it scales the image - struct fx_framebuffer effects_buffer; // Buffer used for effects - struct fx_framebuffer effects_buffer_swapped; // Swap buffer used for effects + // Buffer used for effects + struct fx_framebuffer effects_buffer; + // Swap buffer used for effects + struct fx_framebuffer effects_buffer_swapped; + + // The region where there's blur + pixman_region32_t blur_padding_region; bool blur_buffer_dirty; @@ -155,12 +165,14 @@ struct fx_renderer { } shaders; }; -struct fx_renderer *fx_renderer_create(struct wlr_egl *egl); +struct fx_renderer *fx_renderer_create(struct wlr_egl *egl, struct wlr_output *output); void fx_renderer_fini(struct fx_renderer *renderer); void fx_renderer_begin(struct fx_renderer *renderer, int width, int height); +void fx_renderer_end(struct fx_renderer *renderer); + void fx_renderer_clear(const float color[static 4]); void fx_renderer_scissor(struct wlr_box *box); diff --git a/include/sway/tree/workspace.h b/include/sway/tree/workspace.h index 2ff51ea3..d25afbb2 100644 --- a/include/sway/tree/workspace.h +++ b/include/sway/tree/workspace.h @@ -92,7 +92,8 @@ struct sway_output *workspace_output_get_highest_available( void workspace_detect_urgent(struct sway_workspace *workspace); -bool should_workspace_have_blur(struct sway_workspace *ws); +bool workspace_get_blur_info(struct sway_workspace *ws, + pixman_region32_t *blur_region); void workspace_for_each_container(struct sway_workspace *ws, void (*f)(struct sway_container *con, void *data), void *data); diff --git a/sway/desktop/fx_renderer/fx_framebuffer.c b/sway/desktop/fx_renderer/fx_framebuffer.c index 3ef3129a..dd8c27b1 100644 --- a/sway/desktop/fx_renderer/fx_framebuffer.c +++ b/sway/desktop/fx_renderer/fx_framebuffer.c @@ -67,17 +67,11 @@ void fx_framebuffer_add_stencil_buffer(struct fx_framebuffer *buffer, int width, if (first_alloc || buffer->stencil_buffer.width != width || buffer->stencil_buffer.height != height) { glBindRenderbuffer(GL_RENDERBUFFER, buffer->stencil_buffer.rb); glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, width, height); - glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, buffer->stencil_buffer.rb); buffer->stencil_buffer.width = width; buffer->stencil_buffer.height = height; - - GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); - if (status != GL_FRAMEBUFFER_COMPLETE) { - sway_log(SWAY_ERROR, "Stencil buffer incomplete, couldn't create! (FB status: %i)", status); - return; - } - sway_log(SWAY_DEBUG, "Stencil buffer created, status %i", status); } + + glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, buffer->stencil_buffer.rb); } void fx_framebuffer_release(struct fx_framebuffer *buffer) { diff --git a/sway/desktop/fx_renderer/fx_renderer.c b/sway/desktop/fx_renderer/fx_renderer.c index 81841a04..c0a39716 100644 --- a/sway/desktop/fx_renderer/fx_renderer.c +++ b/sway/desktop/fx_renderer/fx_renderer.c @@ -15,6 +15,8 @@ #include "log.h" #include "sway/desktop/fx_renderer/fx_framebuffer.h" #include "sway/desktop/fx_renderer/fx_renderer.h" +#include "sway/desktop/fx_renderer/fx_stencilbuffer.h" +#include "sway/desktop/fx_renderer/fx_texture.h" #include "sway/desktop/fx_renderer/matrix.h" #include "sway/server.h" @@ -251,12 +253,14 @@ static void load_gl_proc(void *proc_ptr, const char *name) { *(void **)proc_ptr = proc; } -struct fx_renderer *fx_renderer_create(struct wlr_egl *egl) { +struct fx_renderer *fx_renderer_create(struct wlr_egl *egl, struct wlr_output *wlr_output) { struct fx_renderer *renderer = calloc(1, sizeof(struct fx_renderer)); if (renderer == NULL) { return NULL; } + renderer->wlr_output = wlr_output; + // TODO: wlr_egl_make_current or eglMakeCurrent? // TODO: assert instead of conditional statement? if (!eglMakeCurrent(wlr_egl_get_display(egl), EGL_NO_SURFACE, EGL_NO_SURFACE, @@ -265,8 +269,9 @@ struct fx_renderer *fx_renderer_create(struct wlr_egl *egl) { return NULL; } - renderer->main_buffer = fx_framebuffer_create(); + renderer->wlr_buffer = fx_framebuffer_create(); renderer->blur_buffer = fx_framebuffer_create(); + renderer->blur_saved_pixels_buffer = fx_framebuffer_create(); renderer->effects_buffer = fx_framebuffer_create(); renderer->effects_buffer_swapped = fx_framebuffer_create(); @@ -385,8 +390,8 @@ error: } void fx_renderer_fini(struct fx_renderer *renderer) { - fx_framebuffer_release(&renderer->main_buffer); fx_framebuffer_release(&renderer->blur_buffer); + fx_framebuffer_release(&renderer->blur_saved_pixels_buffer); fx_framebuffer_release(&renderer->effects_buffer); fx_framebuffer_release(&renderer->effects_buffer_swapped); } @@ -396,32 +401,36 @@ void fx_renderer_begin(struct fx_renderer *renderer, int width, int height) { renderer->viewport_width = width; renderer->viewport_height = height; - // Store the wlr framebuffer - GLint wlr_fb = -1; - glGetIntegerv(GL_FRAMEBUFFER_BINDING, &wlr_fb); - if (wlr_fb < 0) { - sway_log(SWAY_ERROR, "Failed to get wlr framebuffer!"); - abort(); - } - renderer->wlr_buffer.fb = wlr_fb; + // Store the wlr FBO + renderer->wlr_buffer.fb = + wlr_gles2_renderer_get_current_fbo(renderer->wlr_output->renderer); + // Get the fx_texture + struct wlr_texture *wlr_texture = wlr_texture_from_buffer( + renderer->wlr_output->renderer, renderer->wlr_output->back_buffer); + renderer->wlr_buffer.texture = fx_texture_from_wlr_texture(wlr_texture); + wlr_texture_destroy(wlr_texture); + // Add the stencil to the wlr fbo + fx_framebuffer_add_stencil_buffer(&renderer->wlr_buffer, width, height); // Create the framebuffers - fx_framebuffer_update(&renderer->main_buffer, width, height); + fx_framebuffer_update(&renderer->blur_saved_pixels_buffer, width, height); fx_framebuffer_update(&renderer->effects_buffer, width, height); fx_framebuffer_update(&renderer->effects_buffer_swapped, width, height); // Add a stencil buffer to the main buffer & bind the main buffer - fx_framebuffer_bind(&renderer->main_buffer); - fx_framebuffer_add_stencil_buffer(&renderer->main_buffer, width, height); + fx_framebuffer_bind(&renderer->wlr_buffer); + + pixman_region32_init(&renderer->blur_padding_region); // refresh projection matrix matrix_projection(renderer->projection, width, height, WL_OUTPUT_TRANSFORM_FLIPPED_180); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); +} - // Bind to our main framebuffer - fx_framebuffer_bind(&renderer->main_buffer); +void fx_renderer_end(struct fx_renderer *renderer) { + pixman_region32_fini(&renderer->blur_padding_region); } void fx_renderer_clear(const float color[static 4]) { diff --git a/sway/desktop/output.c b/sway/desktop/output.c index 5d61186f..911bffbb 100644 --- a/sway/desktop/output.c +++ b/sway/desktop/output.c @@ -697,36 +697,6 @@ static void damage_surface_iterator(struct sway_output *output, } pixman_region32_translate(&damage, box.x, box.y); - // Extend view/layer damage size - int effect_size = 0; - if (view && view->container->blur_enabled) { - // Don't check for shadow, gets extended in `output_damage_whole_container` - effect_size = config_get_blur_size(); - } else if (wlr_surface_is_layer_surface(surface)) { - struct wlr_layer_surface_v1 *layer = wlr_layer_surface_v1_from_wlr_surface(surface); - struct sway_layer_surface *sway_layer = layer_from_wlr_layer_surface_v1(layer); - int blur_size = sway_layer->has_blur? config_get_blur_size(): 0; - int shadow_sigma = sway_layer->has_shadow? config->shadow_blur_sigma: 0; - effect_size = MAX(blur_size, shadow_sigma); - } - if (effect_size > 0) { - if (pixman_region32_not_empty(&damage)) { - int output_width, output_height; - wlr_output_transformed_resolution(output->wlr_output, &output_width, &output_height); - int32_t damage_width = damage.extents.x2 - damage.extents.x1; - int32_t damage_height = damage.extents.y2 - damage.extents.y1; - if (damage_width > output_width || damage_height > output_height) { - pixman_region32_intersect_rect(&damage, &damage, 0, 0, output_width, output_height); - } else { - wlr_region_expand(&damage, &damage, effect_size); - } - } - box.x -= effect_size; - box.y -= effect_size; - box.width += effect_size * 2; - box.height += effect_size * 2; - } - if (wlr_damage_ring_add(&output->damage_ring, &damage)) { wlr_output_schedule_frame(output->wlr_output); } @@ -983,7 +953,7 @@ void handle_new_output(struct wl_listener *listener, void *data) { // Init FX Renderer struct wlr_egl *egl = wlr_gles2_renderer_get_egl(server->wlr_renderer); - output->renderer = fx_renderer_create(egl); + output->renderer = fx_renderer_create(egl, wlr_output); if (!output->renderer) { sway_log(SWAY_ERROR, "Failed to create fx_renderer"); abort(); diff --git a/sway/desktop/render.c b/sway/desktop/render.c index c5fe22a7..d97c3609 100644 --- a/sway/desktop/render.c +++ b/sway/desktop/render.c @@ -44,16 +44,6 @@ struct decoration_data get_undecorated_decoration_data() { }; } -// TODO: contribute wlroots function to allow creating an fbox from a box? -struct wlr_fbox wlr_fbox_from_wlr_box(struct wlr_box *box) { - return (struct wlr_fbox) { - .x = box->x, - .y = box->y, - .width = box->width, - .height = box->height, - }; -} - // TODO: Remove this ugly abomination with a complete border rework... enum corner_location get_rotated_corner(enum corner_location corner_location, enum wl_output_transform transform) { @@ -239,11 +229,11 @@ struct fx_framebuffer *get_main_buffer_blur(struct fx_renderer *renderer, struct wlr_region_expand(&damage, &damage, config_get_blur_size()); // Initially blur main_buffer content into the effects_buffers - struct fx_framebuffer *current_buffer = &renderer->main_buffer; + struct fx_framebuffer *current_buffer = &renderer->wlr_buffer; // Bind to blur framebuffer fx_framebuffer_bind(&renderer->effects_buffer); - glBindTexture(renderer->main_buffer.texture.target, renderer->main_buffer.texture.id); + glBindTexture(renderer->wlr_buffer.texture.target, renderer->wlr_buffer.texture.id); // damage region will be scaled, make a temp pixman_region32_t tempDamage; @@ -271,61 +261,42 @@ struct fx_framebuffer *get_main_buffer_blur(struct fx_renderer *renderer, struct pixman_region32_fini(&damage); // Bind back to the default buffer - fx_framebuffer_bind(&renderer->main_buffer); + fx_framebuffer_bind(&renderer->wlr_buffer); return current_buffer; } -void render_blur(bool optimized, struct sway_output *output, - pixman_region32_t *output_damage, const struct wlr_fbox *src_box, - const struct wlr_box *dst_box, pixman_region32_t *opaque_region, - int surface_width, int surface_height, int32_t surface_scale, - int corner_radius, bool should_round_top) { +void render_blur(bool optimized, struct sway_output *output, pixman_region32_t *output_damage, + const struct wlr_box *dst_box, pixman_region32_t *opaque_region, int corner_radius, + bool should_round_top) { struct wlr_output *wlr_output = output->wlr_output; struct fx_renderer *renderer = output->renderer; // Check if damage is inside of box rect pixman_region32_t damage = create_damage(*dst_box, output_damage); - pixman_region32_t inverse_opaque; - pixman_region32_init(&inverse_opaque); + pixman_region32_t translucent_region; + pixman_region32_init(&translucent_region); if (!pixman_region32_not_empty(&damage)) { goto damage_finish; } - /* - * Capture the back_buffer and blur it - */ - - pixman_box32_t surface_box = { - .x1 = 0, - .y1 = 0, - .x2 = dst_box->width / wlr_output->scale, - .y2 = dst_box->height / wlr_output->scale, - }; - - wlr_region_scale(&inverse_opaque, &inverse_opaque, wlr_output->scale); - - // Gets the non opaque region - pixman_region32_copy(&inverse_opaque, opaque_region); - pixman_region32_inverse(&inverse_opaque, &inverse_opaque, &surface_box); - pixman_region32_intersect_rect(&inverse_opaque, &inverse_opaque, 0, 0, - surface_width * surface_scale, - surface_height * surface_scale); - if (!pixman_region32_not_empty(&inverse_opaque)) { + // Gets the translucent region + pixman_box32_t surface_box = { 0, 0, dst_box->width, dst_box->height }; + pixman_region32_copy(&translucent_region, opaque_region); + pixman_region32_inverse(&translucent_region, &translucent_region, &surface_box); + if (!pixman_region32_not_empty(&translucent_region)) { goto damage_finish; } - wlr_region_scale(&inverse_opaque, &inverse_opaque, wlr_output->scale); - struct fx_framebuffer *buffer = &renderer->blur_buffer; if (!buffer->texture.id || !optimized) { - pixman_region32_translate(&inverse_opaque, dst_box->x, dst_box->y); - pixman_region32_intersect(&inverse_opaque, &inverse_opaque, &damage); + pixman_region32_translate(&translucent_region, dst_box->x, dst_box->y); + pixman_region32_intersect(&translucent_region, &translucent_region, &damage); // Render the blur into its own buffer - buffer = get_main_buffer_blur(renderer, output, &inverse_opaque, dst_box); + buffer = get_main_buffer_blur(renderer, output, &translucent_region, dst_box); } // Draw the blurred texture @@ -337,11 +308,11 @@ void render_blur(bool optimized, struct sway_output *output, struct decoration_data deco_data = get_undecorated_decoration_data(); deco_data.corner_radius = corner_radius; deco_data.has_titlebar = should_round_top; - render_texture(wlr_output, &damage, &buffer->texture, src_box, dst_box, matrix, deco_data); + render_texture(wlr_output, &damage, &buffer->texture, NULL, dst_box, matrix, deco_data); damage_finish: pixman_region32_fini(&damage); - pixman_region32_fini(&inverse_opaque); + pixman_region32_fini(&translucent_region); } // _box.x and .y are expected to be layout-local @@ -428,7 +399,6 @@ static void render_surface_iterator(struct sway_output *output, dst_box.x = fmax(dst_box.x, clip_box->x); dst_box.y = fmax(dst_box.y, clip_box->y); } - scale_box(&dst_box, wlr_output->scale); struct decoration_data deco_data = data->deco_data; @@ -450,15 +420,9 @@ static void render_surface_iterator(struct sway_output *output, } if (has_alpha) { - bool should_optimize_blur = view ? - !container_is_floating_or_child(view->container) || config->blur_xray - : false; - struct wlr_box monitor_box = get_monitor_box(wlr_output); - wlr_box_transform(&monitor_box, &monitor_box, - wlr_output_transform_invert(wlr_output->transform), monitor_box.width, monitor_box.height); - struct wlr_fbox blur_src_box = wlr_fbox_from_wlr_box(&monitor_box); - render_blur(should_optimize_blur, output, output_damage, &blur_src_box, &dst_box, &opaque_region, - surface->current.width, surface->current.height, surface->current.scale, + bool should_optimize_blur = view ? !container_is_floating_or_child(view->container) || + config->blur_xray : false; + render_blur(should_optimize_blur, output, output_damage, &dst_box, &opaque_region, deco_data.corner_radius, deco_data.has_titlebar); } @@ -577,7 +541,7 @@ void render_output_blur(struct sway_output *output, pixman_region32_t *damage) { fx_renderer_clear(clear_color); } render_whole_output(renderer, wlr_output, &fake_damage, &buffer->texture); - fx_framebuffer_bind(&renderer->main_buffer); + fx_framebuffer_bind(&renderer->wlr_buffer); pixman_region32_fini(&fake_damage); @@ -832,13 +796,9 @@ static void render_saved_view(struct sway_view *view, struct sway_output *output pixman_region32_init(&opaque_region); pixman_region32_union_rect(&opaque_region, &opaque_region, 0, 0, 0, 0); - struct wlr_box monitor_box = get_monitor_box(wlr_output); - wlr_box_transform(&monitor_box, &monitor_box, - wlr_output_transform_invert(wlr_output->transform), monitor_box.width, monitor_box.height); - struct wlr_fbox src_box = wlr_fbox_from_wlr_box(&monitor_box); bool should_optimize_blur = !container_is_floating_or_child(view->container) || config->blur_xray; - render_blur(should_optimize_blur, output, damage, &src_box, &dst_box, &opaque_region, - saved_buf->width, saved_buf->height, 1, deco_data.corner_radius, deco_data.has_titlebar); + render_blur(should_optimize_blur, output, damage, &dst_box, &opaque_region, + deco_data.corner_radius, deco_data.has_titlebar); pixman_region32_fini(&opaque_region); } @@ -1792,18 +1752,12 @@ void output_render(struct sway_output *output, struct timespec *when, return; } - /* we need to track extended damage for blur (as it is expanded in output.c), - before we expand it again later in this function - */ - pixman_region32_t extended_damage; - pixman_region32_init(&extended_damage); - pixman_region32_copy(&extended_damage, damage); - struct sway_container *fullscreen_con = root->fullscreen_global; if (!fullscreen_con) { fullscreen_con = workspace->current.fullscreen; } + // TODO: generate the monitor box in fx_renderer (since it already has a wlr_output) struct wlr_box monitor_box = get_monitor_box(wlr_output); wlr_box_transform(&monitor_box, &monitor_box, wlr_output_transform_invert(wlr_output->transform), @@ -1816,7 +1770,6 @@ void output_render(struct sway_output *output, struct timespec *when, if (debug.damage == DAMAGE_RERENDER) { pixman_region32_union_rect(damage, damage, 0, 0, output_width, output_height); - pixman_region32_copy(&extended_damage, damage); } if (!pixman_region32_not_empty(damage)) { @@ -1825,9 +1778,7 @@ void output_render(struct sway_output *output, struct timespec *when, } if (debug.damage == DAMAGE_HIGHLIGHT) { - fx_framebuffer_bind(&renderer->wlr_buffer); fx_renderer_clear((float[]){1, 1, 0, 1}); - fx_framebuffer_bind(&renderer->main_buffer); } if (server.session_lock.locked) { @@ -1903,24 +1854,57 @@ void output_render(struct sway_output *output, struct timespec *when, render_unmanaged(output, damage, &root->xwayland_unmanaged); #endif } else { - bool workspace_has_blur = should_workspace_have_blur(workspace); + pixman_region32_t blur_region; + pixman_region32_init(&blur_region); + bool workspace_has_blur = workspace_get_blur_info(workspace, &blur_region); + // Expand the damage to compensate for blur if (workspace_has_blur) { - if (config_should_parameters_blur() && renderer->blur_buffer_dirty) { + // Skip the blur artifact prevention if damaging the whole viewport + if (renderer->blur_buffer_dirty) { // Needs to be extended before clearing - pixman_region32_union_rect(damage, damage, 0, 0, output_width, output_height); - pixman_region32_union_rect(&extended_damage, &extended_damage, 0, 0, output_width, output_height); - } - - // ensure that the damage isn't expanding past the output's size - int32_t damage_width = damage->extents.x2 - damage->extents.x1; - int32_t damage_height = damage->extents.y2 - damage->extents.y1; - if (damage_width > output_width || damage_height > output_height) { - pixman_region32_intersect_rect(damage, damage, 0, 0, output_width, output_height); - pixman_region32_intersect_rect(&extended_damage, &extended_damage, 0, 0, output_width, output_height); + pixman_region32_union_rect(damage, damage, + 0, 0, output_width, output_height); } else { - wlr_region_expand(damage, damage, config_get_blur_size()); + // copy the surrounding content where the blur would display artifacts + // and draw it above the artifacts + + // ensure that the damage isn't expanding past the output's size + int32_t damage_width = damage->extents.x2 - damage->extents.x1; + int32_t damage_height = damage->extents.y2 - damage->extents.y1; + if (damage_width > output_width || damage_height > output_height) { + pixman_region32_intersect_rect(damage, damage, + 0, 0, output_width, output_height); + } else { + // Expand the original damage to compensate for surrounding + // blurred views to avoid sharp edges between damage regions + wlr_region_expand(damage, damage, config_get_blur_size()); + } + + pixman_region32_t extended_damage; + pixman_region32_init(&extended_damage); + pixman_region32_intersect(&extended_damage, damage, &blur_region); + // Expand the region to compensate for blur artifacts + wlr_region_expand(&extended_damage, &extended_damage, config_get_blur_size()); + // Limit to the monitors viewport + pixman_region32_intersect_rect(&extended_damage, &extended_damage, + 0, 0, output_width, output_height); + + // capture the padding pixels around the blur where artifacts will be drawn + pixman_region32_subtract(&renderer->blur_padding_region, + &extended_damage, damage); + // Combine into the surface damage (we need to redraw the padding area as well) + pixman_region32_union(damage, damage, &extended_damage); + pixman_region32_fini(&extended_damage); + + // Capture the padding pixels before blur for later use + fx_framebuffer_bind(&renderer->blur_saved_pixels_buffer); + // TODO: Investigate blitting instead + render_whole_output(renderer, wlr_output, + &renderer->blur_padding_region, &renderer->wlr_buffer.texture); + fx_framebuffer_bind(&renderer->wlr_buffer); } } + pixman_region32_fini(&blur_region); float clear_color[] = {0.25f, 0.25f, 0.25f, 1.0f}; @@ -1937,7 +1921,7 @@ void output_render(struct sway_output *output, struct timespec *when, &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM]); // check if the background needs to be blurred - if (config_should_parameters_blur() && renderer->blur_buffer_dirty && workspace_has_blur) { + if (workspace_has_blur && renderer->blur_buffer_dirty) { render_output_blur(output, damage); } @@ -1985,21 +1969,15 @@ render_overlay: render_drag_icons(output, damage, &root->drag_icons); renderer_end: - // Draw the contents of our buffer into the wlr buffer - fx_framebuffer_bind(&renderer->wlr_buffer); - - float clear_color[] = {0.0f, 0.0f, 0.0f, 1.0f}; - if (pixman_region32_not_empty(&extended_damage)) { - int nrects; - pixman_box32_t *rects = pixman_region32_rectangles(&extended_damage, &nrects); - for (int i = 0; i < nrects; ++i) { - scissor_output(wlr_output, &rects[i]); - fx_renderer_clear(clear_color); - } + // Not needed if we damaged the whole viewport + if (!renderer->blur_buffer_dirty) { + // Render the saved pixels over the blur artifacts + // TODO: Investigate blitting instead + render_whole_output(renderer, wlr_output, &renderer->blur_padding_region, + &renderer->blur_saved_pixels_buffer.texture); } - render_whole_output(renderer, wlr_output, &extended_damage, &renderer->main_buffer.texture); - + fx_renderer_end(output->renderer); fx_renderer_scissor(NULL); // Draw the software cursors @@ -2011,8 +1989,7 @@ renderer_end: pixman_region32_init(&frame_damage); enum wl_output_transform transform = wlr_output_transform_invert(wlr_output->transform); - wlr_region_transform(&frame_damage, &extended_damage, transform, output_width, output_height); - pixman_region32_fini(&extended_damage); + wlr_region_transform(&frame_damage, damage, transform, output_width, output_height); if (debug.damage != DAMAGE_DEFAULT) { pixman_region32_union_rect(&frame_damage, &frame_damage, diff --git a/sway/tree/workspace.c b/sway/tree/workspace.c index 8bc62f3f..7e7146dd 100644 --- a/sway/tree/workspace.c +++ b/sway/tree/workspace.c @@ -692,24 +692,39 @@ void workspace_detect_urgent(struct sway_workspace *workspace) { } } -static bool find_blurred_con_iterator(struct sway_container *con, void *data) { +struct blur_region_data { + struct sway_workspace *ws; + pixman_region32_t *blur_region; +}; + +static void find_blurred_region_iterator(struct sway_container *con, void *data) { struct sway_view *view = con->view; if (!view) { - return false; + return; + } + + struct blur_region_data *region_data = data; + struct sway_workspace *ws = region_data->ws; + pixman_region32_t *blur_region = region_data->blur_region; + + if (con->blur_enabled && !view->surface->opaque) { + pixman_region32_union_rect(blur_region, blur_region, + floor(con->current.x) - ws->output->lx, + floor(con->current.y) - ws->output->ly, + con->current.width, con->current.height); } - return con->blur_enabled && !view->surface->opaque; } -bool should_workspace_have_blur(struct sway_workspace *ws) { - if (!workspace_is_visible(ws)) { +bool workspace_get_blur_info(struct sway_workspace *ws, pixman_region32_t *blur_region) { + if (!workspace_is_visible(ws) || !config_should_parameters_blur()) { return false; } - if ((bool)workspace_find_container(ws, find_blurred_con_iterator, NULL)) { - return true; - } + // Each toplevel + struct blur_region_data data = { ws, blur_region }; + workspace_for_each_container(ws, find_blurred_region_iterator, &data); - // Check if any layer-shell surfaces will render effects + // Each Layer struct sway_output *sway_output = ws->output; size_t len = sizeof(sway_output->layers) / sizeof(sway_output->layers[0]); for (size_t i = 0; i < len; ++i) { @@ -717,12 +732,14 @@ bool should_workspace_have_blur(struct sway_workspace *ws) { wl_list_for_each(lsurface, &sway_output->layers[i], link) { if (lsurface->has_blur && !lsurface->layer_surface->surface->opaque && lsurface->layer != ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND) { - return true; + struct wlr_box *geo = &lsurface->geo; + pixman_region32_union_rect(blur_region, blur_region, + geo->x, geo->y, geo->width, geo->height); } } } - return false; + return pixman_region32_not_empty(blur_region); } void workspace_for_each_container(struct sway_workspace *ws,