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 <[email protected]>

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,