scenefx: rebase against v0.8

patches/scenefx/scenefx.patch

@@ -1,64 +1,58 @@
-From 2d4fb60abd6284236ce4ba0b9c3b562165937963 Mon Sep 17 00:00:00 2001
+From a0a4de0305a5f06431f8162d37070fffd9ad9dd8 Mon Sep 17 00:00:00 2001
 From: wochap <gean.marroquin@gmail.com>
-Date: Fri, 5 Jul 2024 11:45:43 -0500
+Date: Tue, 24 Dec 2024 21:49:50 -0500
-Subject: [PATCH] implement scenefx
+Subject: [PATCH] feat: implement scenefx
 
 ---
  Makefile     |   2 +-
- client.h     |  11 +++-
+ client.h     |  10 ++-
- config.def.h |  28 ++++++++-
+ config.def.h |  28 +++++-
- dwl.c        | 160 +++++++++++++++++++++++++++++++++++++++++++++++++--
+ dwl.c        | 236 ++++++++++++++++++++++++++++++++++++++++++++++++++-
- 4 files changed, 191 insertions(+), 10 deletions(-)
+ 4 files changed, 268 insertions(+), 8 deletions(-)
 
 diff --git a/Makefile b/Makefile
-index 0d651e7..0ae18a7 100644
+index 3358bae..20b15bb 100644
 --- a/Makefile
 +++ b/Makefile
 @@ -12,7 +12,7 @@ DWLDEVCFLAGS = -g -pedantic -Wall -Wextra -Wdeclaration-after-statement \
  	-Wfloat-conversion
  
  # CFLAGS / LDFLAGS
--PKGS      = wlroots wayland-server xkbcommon libinput $(XLIBS)
+-PKGS      = wlroots-0.18 wayland-server xkbcommon libinput $(XLIBS)
-+PKGS      = scenefx wlroots wayland-server xkbcommon libinput $(XLIBS)
++PKGS      = scenefx wlroots-0.18 wayland-server xkbcommon libinput $(XLIBS)
  DWLCFLAGS = `$(PKG_CONFIG) --cflags $(PKGS)` $(DWLCPPFLAGS) $(DWLDEVCFLAGS) $(CFLAGS)
  LDLIBS    = `$(PKG_CONFIG) --libs $(PKGS)` -lm $(LIBS)
  
 diff --git a/client.h b/client.h
-index 42f225f..f75b3ff 100644
+index 42f225f..12faec4 100644
 --- a/client.h
 +++ b/client.h
-@@ -131,7 +131,7 @@ client_get_appid(Client *c)
+@@ -138,8 +138,8 @@ client_get_clip(Client *c, struct wlr_box *clip)
- 	return c->surface.xdg->toplevel->app_id;
+ 	*clip = (struct wlr_box){
- }
+ 		.x = 0,
- 
+ 		.y = 0,
--static inline void
+-		.width = c->geom.width - c->bw,
-+static inline int
+-		.height = c->geom.height - c->bw,
- client_get_clip(Client *c, struct wlr_box *clip)
++		.width = c->geom.width - c->bw * 2,
- {
++		.height = c->geom.height - c->bw * 2,
- 	struct wlr_box xdg_geom = {0};
+ 	};
-@@ -144,12 +144,19 @@ client_get_clip(Client *c, struct wlr_box *clip)
  
  #ifdef XWAYLAND
- 	if (client_is_x11(c))
+@@ -328,6 +328,12 @@ static inline void
--		return;
+ client_set_border_color(Client *c, const float color[static 4])
-+		return 1;
+ {
- #endif
+ 	int i;
- 
- 	wlr_xdg_surface_get_geometry(c->surface.xdg, &xdg_geom);
- 	clip->x = xdg_geom.x;
- 	clip->y = xdg_geom.y;
 +
-+	if (xdg_geom.width <= c->geom.width - (int)c->bw
++	if (corner_radius > 0) {
-+			&& xdg_geom.height <= c->geom.height - (int)c->bw) {
++		wlr_scene_rect_set_color(c->round_border, color);
-+		return 0;
++		return;
 +	}
 +
-+	return 1;
+ 	for (i = 0; i < 4; i++)
+ 		wlr_scene_rect_set_color(c->border[i], color);
  }
- 
- static inline void
 diff --git a/config.def.h b/config.def.h
-index 22d2171..d28e698 100644
+index 22d2171..a7ebe80 100644
 --- a/config.def.h
 +++ b/config.def.h
 @@ -12,7 +12,33 @@ static const float bordercolor[]           = COLOR(0x444444ff);
@@ -73,14 +67,14 @@ index 22d2171..d28e698 100644
 +static const float opacity_active = 1.0;
 +
 +static const int shadow = 1; /* flag to enable shadow */
-+static const int shadow_only_floating = 0; /* only apply shadow to floating windows */
++static const int shadow_only_floating = 1; /* only apply shadow to floating windows */
-+static const struct wlr_render_color shadow_color = COLOR(0x0000FFff);
++static const float shadow_color[4] = COLOR(0x0000FFff);
-+static const struct wlr_render_color shadow_color_focus = COLOR(0xFF0000ff);
++static const float shadow_color_focus[4] = COLOR(0xFF0000ff);
 +static const int shadow_blur_sigma = 20;
 +static const int shadow_blur_sigma_focus = 40;
-+static const char *const shadow_ignore_list[] = { "xdg-desktop-portal-gtk", NULL }; /* list of app-id to ignore */
 +
-+static const int corner_radius = 0; /* 0 disables corner_radius */
++static const int corner_radius = 8; /* 0 disables corner_radius */
++static const int corner_radius_inner = 3; /* 0 disables corner_radius */
 +
 +static const int blur = 1; /* flag to enable blur */
 +static const int blur_optimized = 1;
@@ -97,21 +91,24 @@ index 22d2171..d28e698 100644
  /* tagging - TAGCOUNT must be no greater than 31 */
  #define TAGCOUNT (9)
 diff --git a/dwl.c b/dwl.c
-index dc0437e..d69054a 100644
+index 5bf995e..a9f8277 100644
 --- a/dwl.c
 +++ b/dwl.c
-@@ -10,6 +10,10 @@
+@@ -10,8 +10,13 @@
  #include <stdlib.h>
  #include <sys/wait.h>
  #include <time.h>
 +#include <scenefx/render/fx_renderer/fx_renderer.h>
 +#include <scenefx/types/fx/blur_data.h>
-+#include <scenefx/types/fx/shadow_data.h>
++#include <scenefx/types/fx/corner_location.h>
 +#include <scenefx/types/wlr_scene.h>
  #include <unistd.h>
  #include <wayland-server-core.h>
++#include <wayland-util.h>
  #include <wlr/backend.h>
-@@ -42,7 +46,6 @@
+ #include <wlr/backend/libinput.h>
+ #include <wlr/render/allocator.h>
+@@ -43,7 +48,6 @@
  #include <wlr/types/wlr_primary_selection.h>
  #include <wlr/types/wlr_primary_selection_v1.h>
  #include <wlr/types/wlr_relative_pointer_v1.h>
@@ -119,84 +116,98 @@ index dc0437e..d69054a 100644
  #include <wlr/types/wlr_screencopy_v1.h>
  #include <wlr/types/wlr_seat.h>
  #include <wlr/types/wlr_server_decoration.h>
-@@ -140,6 +143,10 @@ typedef struct {
+@@ -141,6 +145,12 @@ typedef struct {
  	uint32_t tags;
  	int isfloating, isurgent, isfullscreen;
  	uint32_t resize; /* configure serial of a pending resize */
 +
 +	float opacity;
 +	int corner_radius;
-+	struct shadow_data shadow_data;
++	struct wlr_scene_shadow *shadow;
++	int has_shadow_enabled;
++	struct wlr_scene_rect *round_border;
  } Client;
  
  typedef struct {
-@@ -351,6 +358,9 @@ static Monitor *xytomon(double x, double y);
+@@ -355,6 +365,9 @@ static Monitor *xytomon(double x, double y);
  static void xytonode(double x, double y, struct wlr_surface **psurface,
  		Client **pc, LayerSurface **pl, double *nx, double *ny);
  static void zoom(const Arg *arg);
-+static int in_shadow_ignore_list(const char *str);
 +static void iter_xdg_scene_buffers(struct wlr_scene_buffer *buffer, int sx, int sy, void *user_data);
-+static void iter_xdg_scene_buffers_shadow(struct wlr_scene_buffer *buffer, int sx, int sy, void *user_data);
++static void iter_xdg_scene_buffers_opacity(struct wlr_scene_buffer *buffer, int sx, int sy, void *user_data);
++static void output_configure_scene(struct wlr_scene_node *node, Client *c);
  
  /* variables */
  static const char broken[] = "broken";
-@@ -1045,6 +1055,13 @@ createnotify(struct wl_listener *listener, void *data)
+@@ -366,6 +379,8 @@ static struct wl_event_loop *event_loop;
- 	wlr_xdg_toplevel_set_wm_capabilities(xdg_surface->toplevel,
+ static struct wlr_backend *backend;
- 			WLR_XDG_TOPLEVEL_WM_CAPABILITIES_FULLSCREEN);
+ static struct wlr_scene *scene;
+ static struct wlr_scene_tree *layers[NUM_LAYERS];
++/* TODO: implement wlr_scene_optimized_blur */
++/* static struct wlr_scene_optimized_blur *blur_layer; */
+ static struct wlr_scene_tree *drag_icon;
+ /* Map from ZWLR_LAYER_SHELL_* constants to Lyr* enum */
+ static const int layermap[] = { LyrBg, LyrBottom, LyrTop, LyrOverlay };
+@@ -413,6 +428,8 @@ static struct wlr_box sgeom;
+ static struct wl_list mons;
+ static Monitor *selmon;
+ 
++static float transparent[4] = {0.1f, 0.1f, 0.1f, 0.0f};
++
+ #ifdef XWAYLAND
+ static void activatex11(struct wl_listener *listener, void *data);
+ static void associatex11(struct wl_listener *listener, void *data);
+@@ -1061,6 +1078,9 @@ createnotify(struct wl_listener *listener, void *data)
+ 	c->surface.xdg = toplevel->base;
+ 	c->bw = borderpx;
  
 +	c->opacity = opacity;
 +	c->corner_radius = corner_radius;
-+	c->shadow_data = shadow_data_get_default();
-+	c->shadow_data.enabled = shadow_only_floating != 1 && !in_shadow_ignore_list(client_get_appid(c));
-+	c->shadow_data.blur_sigma = shadow_blur_sigma;
-+	c->shadow_data.color = shadow_color;
 +
- 	LISTEN(&xdg_surface->events.destroy, &c->destroy, destroynotify);
+ 	LISTEN(&toplevel->base->surface->events.commit, &c->commit, commitnotify);
- 	LISTEN(&xdg_surface->surface->events.commit, &c->commit, commitnotify);
+ 	LISTEN(&toplevel->base->surface->events.map, &c->map, mapnotify);
- 	LISTEN(&xdg_surface->surface->events.map, &c->map, mapnotify);
+ 	LISTEN(&toplevel->base->surface->events.unmap, &c->unmap, unmapnotify);
-@@ -1346,8 +1363,21 @@ focusclient(Client *c, int lift)
+@@ -1369,8 +1389,20 @@ focusclient(Client *c, int lift)
  
  		/* Don't change border color if there is an exclusive focus or we are
  		 * handling a drag operation */
 -		if (!exclusive_focus && !seat->drag)
 +		if (!exclusive_focus && !seat->drag) {
  			client_set_border_color(c, focuscolor);
++
 +			if (shadow) {
-+				c->shadow_data.blur_sigma = shadow_blur_sigma_focus;
++				wlr_scene_shadow_set_blur_sigma(c->shadow, shadow_blur_sigma_focus);
-+				c->shadow_data.color = shadow_color_focus;
++				if (c->has_shadow_enabled) {
++					wlr_scene_shadow_set_color(c->shadow, shadow_color_focus);
++				}
 +			}
 +			if (opacity) {
 +				c->opacity = opacity_active;
-+			}
++				wlr_scene_node_for_each_buffer(&c->scene_surface->node, iter_xdg_scene_buffers_opacity, c);
-+			if (opacity) {
-+				wlr_scene_node_for_each_buffer(&c->scene_surface->node, iter_xdg_scene_buffers, c);
-+			} else if (shadow) {
-+				wlr_scene_node_for_each_buffer(&c->scene_surface->node, iter_xdg_scene_buffers_shadow, c);
 +			}
 +		}
  	}
  
  	/* Deactivate old client if focus is changing */
-@@ -1365,6 +1395,18 @@ focusclient(Client *c, int lift)
+@@ -1389,6 +1421,17 @@ focusclient(Client *c, int lift)
- 		 * and probably other clients */
  		} else if (old_c && !client_is_unmanaged(old_c) && (!c || !client_wants_focus(c))) {
  			client_set_border_color(old_c, bordercolor);
+ 
 +			if (shadow) {
-+				old_c->shadow_data.blur_sigma = shadow_blur_sigma;
++				wlr_scene_shadow_set_blur_sigma(old_c->shadow, shadow_blur_sigma);
-+				old_c->shadow_data.color = shadow_color;
++				if (old_c->has_shadow_enabled) {
++					wlr_scene_shadow_set_color(old_c->shadow, shadow_color);
++				}
 +			}
 +			if (opacity) {
 +				old_c->opacity = opacity_inactive;
++				wlr_scene_node_for_each_buffer(&old_c->scene_surface->node, iter_xdg_scene_buffers_opacity, old_c);
 +			}
-+			if (opacity) {
++
-+				wlr_scene_node_for_each_buffer(&old_c->scene_surface->node, iter_xdg_scene_buffers, old_c);
-+			} else if (shadow) {
-+				wlr_scene_node_for_each_buffer(&old_c->scene_surface->node, iter_xdg_scene_buffers_shadow, old_c);
-+			}
- 
  			client_activate_surface(old, 0);
  		}
-@@ -1653,6 +1695,8 @@ mapnotify(struct wl_listener *listener, void *data)
+ 	}
+@@ -1700,6 +1743,8 @@ mapnotify(struct wl_listener *listener, void *data)
  
  	client_get_geometry(c, &c->geom);
  
@@ -205,67 +216,117 @@ index dc0437e..d69054a 100644
  	/* Handle unmanaged clients first so we can return prior create borders */
  	if (client_is_unmanaged(c)) {
  		/* Unmanaged clients always are floating */
-@@ -1692,6 +1736,15 @@ mapnotify(struct wl_listener *listener, void *data)
+@@ -1718,6 +1763,24 @@ mapnotify(struct wl_listener *listener, void *data)
+ 		c->border[i]->node.data = c;
+ 	}
+ 
++	if (corner_radius > 0) {
++		c->round_border = wlr_scene_rect_create(c->scene, 0, 0, c->isurgent ? urgentcolor : bordercolor);
++		c->round_border->node.data = c;
++		wlr_scene_rect_set_corner_radius(c->round_border, c->corner_radius + c->bw);
++		/* Lower the border below the XDG scene tree */
++		wlr_scene_node_lower_to_bottom(&c->round_border->node);
++	}
++
++	if (shadow) {
++		c->shadow = wlr_scene_shadow_create(c->scene, 0, 0, c->corner_radius, shadow_blur_sigma, shadow_color);
++		c->has_shadow_enabled = shadow_only_floating != 1;
++		if (!c->has_shadow_enabled) {
++			wlr_scene_shadow_set_color(c->shadow, transparent);
++		}
++		/* Lower the shadow below the border */
++		wlr_scene_node_lower_to_bottom(&c->shadow->node);
++	}
++
+ 	/* Initialize client geometry with room for border */
+ 	client_set_tiled(c, WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | WLR_EDGE_RIGHT);
+ 	c->geom.width += 2 * c->bw;
+@@ -1739,6 +1802,16 @@ mapnotify(struct wl_listener *listener, void *data)
  	}
  	printstatus();
  
 +	if (shadow && shadow_only_floating) {
-+		if (c->isfloating && !in_shadow_ignore_list(client_get_appid(c))) {
++		if (c->isfloating) {
-+			c->shadow_data.enabled = 1;
++			c->has_shadow_enabled = 1;
++			wlr_scene_shadow_set_color(c->shadow, focustop(c->mon) == c ? shadow_color_focus : shadow_color);
 +		} else {
-+			c->shadow_data.enabled = 0;
++			c->has_shadow_enabled = 0;
++			wlr_scene_shadow_set_color(c->shadow, transparent);
 +		}
-+		wlr_scene_node_for_each_buffer(&c->scene_surface->node, iter_xdg_scene_buffers_shadow, c);
 +	}
 +
  unset_fullscreen:
  	m = c->mon ? c->mon : xytomon(c->geom.x, c->geom.y);
  	wl_list_for_each(w, &clients, link) {
-@@ -2132,6 +2185,7 @@ resize(Client *c, struct wlr_box geo, int interact)
+@@ -2113,6 +2186,8 @@ rendermon(struct wl_listener *listener, void *data)
+ 			goto skip;
+ 	}
+ 
++	output_configure_scene(&m->scene_output->scene->tree.node, NULL);
++
+ 	/*
+ 	 * HACK: The "correct" way to set the gamma is to commit it together with
+ 	 * the rest of the state in one go, but to do that we would need to rewrite
+@@ -2181,6 +2256,8 @@ resize(Client *c, struct wlr_box geo, int interact)
  {
  	struct wlr_box *bbox;
  	struct wlr_box clip;
-+	int should_clip;
++	int blur_sigma;
++	int i;
  
  	if (!c->mon || !c->scene)
  		return;
-@@ -2156,8 +2210,12 @@ resize(Client *c, struct wlr_box geo, int interact)
+@@ -2207,6 +2284,19 @@ resize(Client *c, struct wlr_box geo, int interact)
- 	/* this is a no-op if size hasn't changed */
- 	c->resize = client_set_size(c, c->geom.width - 2 * c->bw,
  			c->geom.height - 2 * c->bw);
--	client_get_clip(c, &clip);
+ 	client_get_clip(c, &clip);
--	wlr_scene_subsurface_tree_set_clip(&c->scene_surface->node, &clip);
+ 	wlr_scene_subsurface_tree_set_clip(&c->scene_surface->node, &clip);
-+	should_clip = client_get_clip(c, &clip);
++
-+	if (should_clip) {
++	if (corner_radius > 0) {
-+		wlr_scene_subsurface_tree_set_clip(&c->scene_surface->node, &clip);
++		wlr_scene_node_set_position(&c->round_border->node, 0, 0);
-+	} else {
++		wlr_scene_rect_set_size(c->round_border, c->geom.width, c->geom.height);
-+		wlr_scene_subsurface_tree_set_clip(&c->scene_surface->node, NULL);
++		for (i = 0; i < 4; i++)
++			wlr_scene_rect_set_color(c->border[i], transparent);
++	}
++
++	if (shadow) {
++		blur_sigma = (int)round(c->shadow->blur_sigma);
++		wlr_scene_node_set_position(&c->shadow->node, -blur_sigma, -blur_sigma);
++		wlr_scene_shadow_set_size(c->shadow, c->geom.width + (blur_sigma) * 2, c->geom.height + (blur_sigma) * 2);
 +	}
  }
  
  void
-@@ -2258,6 +2316,14 @@ setfloating(Client *c, int floating)
+@@ -2307,6 +2397,21 @@ setfloating(Client *c, int floating)
  {
  	Client *p = client_get_parent(c);
  	c->isfloating = floating;
++
 +	if (shadow && shadow_only_floating) {
-+		if (c->isfloating && !in_shadow_ignore_list(client_get_appid(c))) {
++		if (c->isfloating) {
-+			c->shadow_data.enabled = 1;
++			c->has_shadow_enabled = 1;
++			if (c->shadow != NULL) {
++				wlr_scene_shadow_set_color(c->shadow, focustop(c->mon) == c ? shadow_color_focus : shadow_color);
++			}
 +		} else {
-+			c->shadow_data.enabled = 0;
++			c->has_shadow_enabled = 0;
++			if (c->shadow != NULL) {
++				wlr_scene_shadow_set_color(c->shadow, transparent);
++			}
 +		}
-+		wlr_scene_node_for_each_buffer(&c->scene_surface->node, iter_xdg_scene_buffers_shadow, c);
 +	}
++
  	/* If in floating layout do not change the client's layer */
  	if (!c->mon || !client_surface(c)->mapped || !c->mon->lt[c->mon->sellt]->arrange)
  		return;
-@@ -2407,11 +2473,15 @@ setup(void)
+@@ -2457,11 +2562,17 @@ setup(void)
  	drag_icon = wlr_scene_tree_create(&scene->tree);
  	wlr_scene_node_place_below(&drag_icon->node, &layers[LyrBlock]->node);
  
-+	// if (blur) {
++	if (blur) {
-+	// 	wlr_scene_set_blur_data(scene, blur_data);
++		/* TODO: implement wlr_scene_optimized_blur_create */
-+	// }
++		/* blur_layer = wlr_scene_optimized_blur_create(&scene->tree, 0, 0); */
++		wlr_scene_set_blur_data(scene, blur_data);
++	}
 +
  	/* Autocreates a renderer, either Pixman, GLES2 or Vulkan for us. The user
  	 * can also specify a renderer using the WLR_RENDERER env var.
@@ -274,40 +335,47 @@ index dc0437e..d69054a 100644
 -	if (!(drw = wlr_renderer_autocreate(backend)))
 +	if (!(drw = fx_renderer_create(backend)))
  		die("couldn't create renderer");
+ 	LISTEN_STATIC(&drw->events.lost, gpureset);
  
- 	/* Create shm, drm and linux_dmabuf interfaces by ourselves.
+@@ -2871,6 +2982,14 @@ updatemons(struct wl_listener *listener, void *data)
-@@ -2888,8 +2958,14 @@ urgent(struct wl_listener *listener, void *data)
+ 		wlr_scene_node_set_position(&m->fullscreen_bg->node, m->m.x, m->m.y);
+ 		wlr_scene_rect_set_size(m->fullscreen_bg, m->m.width, m->m.height);
+ 
++		/*
++		 * Sets the blur node size to the outputs size. Assumes there's only one
++		 * output. More advanced compositors should either implement per output blur
++		 * nodes or set it to the size of all outputs.
++		 */
++		/* TODO: implement wlr_scene_optimized_blur_set_size */
++		/* wlr_scene_optimized_blur_set_size(blur_layer, m->wlr_output->width, m->wlr_output->height); */
++
+ 		if (m->lock_surface) {
+ 			struct wlr_scene_tree *scene_tree = m->lock_surface->surface->data;
+ 			wlr_scene_node_set_position(&scene_tree->node, m->m.x, m->m.y);
+@@ -2940,8 +3059,16 @@ urgent(struct wl_listener *listener, void *data)
  	c->isurgent = 1;
  	printstatus();
  
 -	if (client_surface(c)->mapped)
 +	if (client_surface(c)->mapped) {
  		client_set_border_color(c, urgentcolor);
++
 +		if (shadow) {
-+			c->shadow_data.blur_sigma = shadow_blur_sigma_focus;
++			wlr_scene_shadow_set_blur_sigma(c->shadow, shadow_blur_sigma_focus);
-+			c->shadow_data.color = shadow_color_focus;
++			if (c->has_shadow_enabled) {
-+			wlr_scene_node_for_each_buffer(&c->scene_surface->node, iter_xdg_scene_buffers_shadow, c);
++				wlr_scene_shadow_set_color(c->shadow, shadow_color_focus);
++			}
 +		}
 +	}
  }
  
  void
-@@ -3001,6 +3077,78 @@ zoom(const Arg *arg)
+@@ -3053,6 +3180,107 @@ zoom(const Arg *arg)
  	arrange(selmon);
  }
  
-+int
++void
-+in_shadow_ignore_list(const char *str) {
++iter_xdg_scene_buffers(struct wlr_scene_buffer *buffer, int sx, int sy, void *user_data)
-+	for (int i = 0; shadow_ignore_list[i] != NULL; i++) {
-+		if (strcmp(shadow_ignore_list[i], str) == 0) {
-+			return 1;
-+		}
-+	}
-+	return 0;
-+}
-+
-+void 
-+iter_xdg_scene_buffers(struct wlr_scene_buffer *buffer, int sx, int sy, void *user_data) 
 +{
 +	Client *c = user_data;
 +	struct wlr_scene_surface * scene_surface = wlr_scene_surface_try_from_buffer(buffer);
@@ -319,35 +387,29 @@ index dc0437e..d69054a 100644
 +
 +	xdg_surface = wlr_xdg_surface_try_from_wlr_surface(scene_surface->surface);
 +
-+	if (c &&
++	if (c && xdg_surface && xdg_surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL) {
-+			xdg_surface &&
++		/* TODO: Be able to set whole decoration_data instead of calling */
-+			xdg_surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL) {
++		/* each individually? */
-+		// TODO: Be able to set whole decoration_data instead of calling
-+		// each individually?
 +		if (opacity) {
 +			wlr_scene_buffer_set_opacity(buffer, c->opacity);
 +		}
 +
 +		if (!wlr_subsurface_try_from_wlr_surface(xdg_surface->surface)) {
-+			if (corner_radius > 0) {
++			if (corner_radius_inner > 0) {
-+				wlr_scene_buffer_set_corner_radius(buffer, c->corner_radius);
++				wlr_scene_buffer_set_corner_radius(buffer, corner_radius_inner, CORNER_LOCATION_ALL);
 +			}
 +
-+			if (shadow) {
++			if (blur) {
-+				wlr_scene_buffer_set_shadow_data(buffer, c->shadow_data);
++				wlr_scene_buffer_set_backdrop_blur(buffer, 1);
++				wlr_scene_buffer_set_backdrop_blur_optimized(buffer, blur_optimized);
++				wlr_scene_buffer_set_backdrop_blur_ignore_transparent(buffer, blur_ignore_transparent);
 +			}
-+
-+			// if (blur) {
-+			// 	wlr_scene_buffer_set_backdrop_blur(buffer, 1);
-+			// 	wlr_scene_buffer_set_backdrop_blur_optimized(buffer, blur_optimized);
-+			// 	wlr_scene_buffer_set_backdrop_blur_ignore_transparent(buffer, blur_ignore_transparent);
-+			// }
 +		}
 +	}
 +}
 +
-+void 
++void
-+iter_xdg_scene_buffers_shadow(struct wlr_scene_buffer *buffer, int sx, int sy, void *user_data) 
++iter_xdg_scene_buffers_opacity(struct wlr_scene_buffer *buffer, int sx, int sy, void *user_data)
 +{
 +	Client *c = user_data;
 +	struct wlr_scene_surface * scene_surface = wlr_scene_surface_try_from_buffer(buffer);
@@ -359,17 +421,60 @@ index dc0437e..d69054a 100644
 +
 +	xdg_surface = wlr_xdg_surface_try_from_wlr_surface(scene_surface->surface);
 +
-+	if (c &&
++	if (c && xdg_surface && xdg_surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL) {
-+			xdg_surface &&
++		/* TODO: Be able to set whole decoration_data instead of calling */
-+			xdg_surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL) {
++		/* each individually? */
-+		if (!wlr_subsurface_try_from_wlr_surface(xdg_surface->surface)) {
++		if (opacity) {
-+			wlr_scene_buffer_set_shadow_data(buffer, c->shadow_data);
++			wlr_scene_buffer_set_opacity(buffer, c->opacity);
++		}
++	}
++}
++
++void
++output_configure_scene(struct wlr_scene_node *node, Client *c)
++{
++	Client *_c;
++	struct wlr_xdg_surface *xdg_surface;
++	struct wlr_scene_node *_node;
++
++	if (!node->enabled) {
++		return;
++	}
++
++	_c = node->data;
++	if (_c) {
++		c = _c;
++	}
++
++	if (node->type == WLR_SCENE_NODE_BUFFER) {
++		struct wlr_scene_buffer *buffer = wlr_scene_buffer_from_node(node);
++
++		struct wlr_scene_surface *scene_surface = wlr_scene_surface_try_from_buffer(buffer);
++		if (!scene_surface) {
++			return;
++		}
++
++		xdg_surface = wlr_xdg_surface_try_from_wlr_surface(scene_surface->surface);
++
++		if (c && xdg_surface && xdg_surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL) {
++			if (opacity) {
++				wlr_scene_buffer_set_opacity(buffer, c->opacity);
++			}
++
++			if (!wlr_subsurface_try_from_wlr_surface(xdg_surface->surface)) {
++				if (corner_radius_inner > 0) {
++					wlr_scene_buffer_set_corner_radius(buffer, corner_radius_inner, CORNER_LOCATION_ALL);
++				}
++			}
++		}
++	} else if (node->type == WLR_SCENE_NODE_TREE) {
++		struct wlr_scene_tree *tree = wl_container_of(node, tree, node);
++		wl_list_for_each(_node, &tree->children, link) {
++			output_configure_scene(_node, c);
 +		}
 +	}
 +}
 +
  #ifdef XWAYLAND
  void
- activatex11(struct wl_listener *listener, void *data)
+ activatex11(struct wl_listener *listener, void *data)
--- 
-2.45.1