#include <assert.h>
 #include <math.h>
 #include <pixman.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <wlr/backend.h>
 #include <wlr/render/swapchain.h>
 #include <wlr/render/drm_syncobj.h>
 #include <wlr/render/wlr_renderer.h>
 #include <wlr/types/wlr_color_management_v1.h>
 #include <wlr/types/wlr_compositor.h>
 #include <wlr/types/wlr_damage_ring.h>
 #include <wlr/types/wlr_gamma_control_v1.h>
 #include <wlr/types/wlr_linux_dmabuf_v1.h>
 #include <wlr/types/wlr_presentation_time.h>
 #include <wlr/util/log.h>
 #include <wlr/util/region.h>
 #include <wlr/util/transform.h>
 
 static bool cce_scene_blur_debug(void);
 
 #include "render/color.h"
 #include "render/tracy.h"
 #include "scenefx/render/fx_renderer/fx_offscreen_buffers.h"
 #include "scenefx/render/pass.h"
 #include "scenefx/types/fx/blur_data.h"
 #include "scenefx/types/fx/clipped_region.h"
 #include "scenefx/types/wlr_scene.h"
 #include "types/fx/clipped_region.h"
 #include "types/wlr_output.h"
 #include "types/wlr_scene.h"
 #include "util/array.h"
 #include "util/env.h"
 #include "util/time.h"
 
 #include <wlr/config.h>
 
 #if WLR_HAS_XWAYLAND
 #include <wlr/xwayland/xwayland.h>
 #endif
 
 #define DMABUF_FEEDBACK_DEBOUNCE_FRAMES  30
 #define HIGHLIGHT_DAMAGE_FADEOUT_TIME   250
 
 #define CURSOR_HISTORY_SIZE 16
 // Only this many of the most recent footprints are damage: a stale cursor
 // can only be baked into a buffer the swapchain still hands back, and a
 // wlroots swapchain holds at most WLR_SWAPCHAIN_CAP (4) — so twice that is
 // a margin, not a guess. Until 2026-10-06 all 16 counted, forever: the
 // trail of a moving cursor was re-rendered (and re-blurred) every frame, and
 // after it stopped, every unrelated frame still pulled in the old trail.
 #define CURSOR_HISTORY_DAMAGE 8
 static struct {
 	int x, y, w, h;
 	bool valid;
 	// The footprint is in this output's coordinates.
 	struct wlr_output *output;
 } g_cursor_history[CURSOR_HISTORY_SIZE];
 static int g_cursor_history_index = 0;
 
 struct wlr_scene_tree *wlr_scene_tree_from_node(struct wlr_scene_node *node) {
 	assert(node->type == WLR_SCENE_NODE_TREE);
 	struct wlr_scene_tree *tree = wl_container_of(node, tree, node);
 	return tree;
 }
 
 struct wlr_scene_rect *wlr_scene_rect_from_node(struct wlr_scene_node *node) {
 	assert(node->type == WLR_SCENE_NODE_RECT);
 	struct wlr_scene_rect *rect = wl_container_of(node, rect, node);
 	return rect;
 }
 
 struct wlr_scene_optimized_blur *wlr_scene_optimized_blur_from_node(
 		struct wlr_scene_node *node) {
 	assert(node->type == WLR_SCENE_NODE_OPTIMIZED_BLUR);
 	struct wlr_scene_optimized_blur *blur_node =
 		wl_container_of(node, blur_node, node);
 	return blur_node;
 }
 
 struct wlr_scene_buffer *wlr_scene_buffer_from_node(
 		struct wlr_scene_node *node) {
 	assert(node->type == WLR_SCENE_NODE_BUFFER);
 	struct wlr_scene_buffer *buffer = wl_container_of(node, buffer, node);
 	return buffer;
 }
 
 struct wlr_scene_shadow *wlr_scene_shadow_from_node(struct wlr_scene_node *node) {
 	assert(node->type == WLR_SCENE_NODE_SHADOW);
 	struct wlr_scene_shadow *shadow = wl_container_of(node, shadow, node);
 	return shadow;
 }
 
 struct wlr_scene_frame *wlr_scene_frame_from_node(struct wlr_scene_node *node) {
 	assert(node->type == WLR_SCENE_NODE_FRAME);
 	struct wlr_scene_frame *frame = wl_container_of(node, frame, node);
 	return frame;
 }
 
 struct wlr_scene_bevel *wlr_scene_bevel_from_node(struct wlr_scene_node *node) {
 	assert(node->type == WLR_SCENE_NODE_BEVEL);
 	struct wlr_scene_bevel *bevel = wl_container_of(node, bevel, node);
 	return bevel;
 }
 
 struct wlr_scene_droplet *wlr_scene_droplet_from_node(struct wlr_scene_node *node) {
 	assert(node->type == WLR_SCENE_NODE_DROPLET);
 	struct wlr_scene_droplet *droplet = wl_container_of(node, droplet, node);
 	return droplet;
 }
 
 struct wlr_scene_blur *wlr_scene_blur_from_node(struct wlr_scene_node *node) {
 	assert(node->type == WLR_SCENE_NODE_BLUR);
 	struct wlr_scene_blur *blur = wl_container_of(node, blur, node);
 	return blur;
 }
 
 struct wlr_scene *scene_node_get_root(struct wlr_scene_node *node) {
 	struct wlr_scene_tree *tree;
 	if (node->type == WLR_SCENE_NODE_TREE) {
 		tree = wlr_scene_tree_from_node(node);
 	} else {
 		tree = node->parent;
 	}
 
 	while (tree->node.parent != NULL) {
 		tree = tree->node.parent;
 	}
 	struct wlr_scene *scene = wl_container_of(tree, scene, tree);
 	return scene;
 }
 
 static void scene_node_init(struct wlr_scene_node *node,
 		enum wlr_scene_node_type type, struct wlr_scene_tree *parent) {
 	*node = (struct wlr_scene_node){
 		.type = type,
 		.parent = parent,
 		.enabled = true,
 	};
 
 	wl_list_init(&node->link);
 
 	wl_signal_init(&node->events.destroy);
 	pixman_region32_init(&node->visible);
 
 	if (parent != NULL) {
 		wl_list_insert(parent->children.prev, &node->link);
 	}
 
 	wlr_addon_set_init(&node->addons);
 }
 
 struct highlight_region {
 	pixman_region32_t region;
 	struct timespec when;
 	struct wl_list link;
 };
 
 static void scene_buffer_set_buffer(struct wlr_scene_buffer *scene_buffer,
 	struct wlr_buffer *buffer);
 static void scene_buffer_set_texture(struct wlr_scene_buffer *scene_buffer,
 	struct wlr_texture *texture);
 
 void wlr_scene_node_destroy(struct wlr_scene_node *node) {
 	if (node == NULL) {
 		return;
 	}
 
 	// We want to call the destroy listeners before we do anything else
 	// in case the destroy signal would like to remove children before they
 	// are recursively destroyed.
 	wl_signal_emit_mutable(&node->events.destroy, NULL);
 	wlr_addon_set_finish(&node->addons);
 
 	wlr_scene_node_set_enabled(node, false);
 
 	struct wlr_scene *scene = scene_node_get_root(node);
 	if (node->type == WLR_SCENE_NODE_BUFFER) {
 		struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
 
 		uint64_t active = scene_buffer->active_outputs;
 		if (active) {
 			struct wlr_scene_output *scene_output;
 			wl_list_for_each(scene_output, &scene->outputs, link) {
 				if (active & (1ull << scene_output->index)) {
 					wl_signal_emit_mutable(&scene_buffer->events.output_leave,
 						scene_output);
 				}
 			}
 		}
 
 		scene_buffer_set_buffer(scene_buffer, NULL);
 		scene_buffer_set_texture(scene_buffer, NULL);
 		pixman_region32_fini(&scene_buffer->opaque_region);
 		wlr_drm_syncobj_timeline_unref(scene_buffer->wait_timeline);
 		linked_node_destroy(&scene_buffer->blur);
 
 		assert(wl_list_empty(&scene_buffer->events.output_leave.listener_list));
 		assert(wl_list_empty(&scene_buffer->events.output_enter.listener_list));
 		assert(wl_list_empty(&scene_buffer->events.outputs_update.listener_list));
 		assert(wl_list_empty(&scene_buffer->events.output_sample.listener_list));
 		assert(wl_list_empty(&scene_buffer->events.frame_done.listener_list));
 	} else if (node->type == WLR_SCENE_NODE_OPTIMIZED_BLUR) {
 		pixman_region32_fini(&wlr_scene_optimized_blur_from_node(node)->baked_region);
 		pixman_region32_fini(&wlr_scene_optimized_blur_from_node(node)->edge_region);
 	} else if (node->type == WLR_SCENE_NODE_TREE) {
 		struct wlr_scene_tree *scene_tree = wlr_scene_tree_from_node(node);
 
 		if (scene_tree == &scene->tree) {
 			assert(!node->parent);
 			struct wlr_scene_output *scene_output, *scene_output_tmp;
 			wl_list_for_each_safe(scene_output, scene_output_tmp, &scene->outputs, link) {
 				wlr_scene_output_destroy(scene_output);
 			}
 
 			wl_list_remove(&scene->linux_dmabuf_v1_destroy.link);
 			wl_list_remove(&scene->gamma_control_manager_v1_destroy.link);
 			wl_list_remove(&scene->gamma_control_manager_v1_set_gamma.link);
 		} else {
 			assert(node->parent);
 		}
 
 		struct wlr_scene_node *child, *child_tmp;
 		wl_list_for_each_safe(child, child_tmp,
 				&scene_tree->children, link) {
 			wlr_scene_node_destroy(child);
 		}
 	} else if (node->type == WLR_SCENE_NODE_BLUR) {
 		struct wlr_scene_blur *blur = wlr_scene_blur_from_node(node);
 		linked_node_destroy(&blur->transparency_mask_source);
 	}
 
 	assert(wl_list_empty(&node->events.destroy.listener_list));
 
 	wl_list_remove(&node->link);
 	pixman_region32_fini(&node->visible);
 	free(node);
 }
 
 static void scene_tree_init(struct wlr_scene_tree *tree,
 		struct wlr_scene_tree *parent) {
 	*tree = (struct wlr_scene_tree){0};
 	scene_node_init(&tree->node, WLR_SCENE_NODE_TREE, parent);
 	wl_list_init(&tree->children);
 }
 
 struct wlr_scene *wlr_scene_create(void) {
 	struct wlr_scene *scene = calloc(1, sizeof(*scene));
 	if (scene == NULL) {
 		return NULL;
 	}
 
 	scene_tree_init(&scene->tree, NULL);
 
 	wl_list_init(&scene->outputs);
 	wl_list_init(&scene->linux_dmabuf_v1_destroy.link);
 	wl_list_init(&scene->gamma_control_manager_v1_destroy.link);
 	wl_list_init(&scene->gamma_control_manager_v1_set_gamma.link);
 
 	scene->restack_xwayland_surfaces = true;
 
 	const char *debug_damage_options[] = {
 		"none",
 		"rerender",
 		"highlight",
 		NULL
 	};
 
 	scene->debug_damage_option = env_parse_switch("WLR_SCENE_DEBUG_DAMAGE", debug_damage_options);
 	scene->direct_scanout = !env_parse_bool("WLR_SCENE_DISABLE_DIRECT_SCANOUT");
 	scene->calculate_visibility = !env_parse_bool("WLR_SCENE_DISABLE_VISIBILITY");
 	scene->highlight_transparent_region = env_parse_bool("WLR_SCENE_HIGHLIGHT_TRANSPARENT_REGION");
 
 	scene->blur_data = blur_data_get_default();
 
 	return scene;
 }
 
 struct wlr_scene_tree *wlr_scene_tree_create(struct wlr_scene_tree *parent) {
 	assert(parent);
 
 	struct wlr_scene_tree *tree = calloc(1, sizeof(*tree));
 	if (tree == NULL) {
 		return NULL;
 	}
 
 	scene_tree_init(tree, parent);
 	return tree;
 }
 
 typedef bool (*scene_node_box_iterator_func_t)(struct wlr_scene_node *node,
 	int sx, int sy, void *data);
 
 static bool _scene_nodes_in_box(struct wlr_scene_node *node, struct wlr_box *box,
 		scene_node_box_iterator_func_t iterator, void *user_data, int lx, int ly) {
 	if (!node->enabled) {
 		return false;
 	}
 
 	switch (node->type) {
 	case WLR_SCENE_NODE_TREE:;
 		struct wlr_scene_tree *scene_tree = wlr_scene_tree_from_node(node);
 		struct wlr_scene_node *child;
 		wl_list_for_each_reverse(child, &scene_tree->children, link) {
 			if (_scene_nodes_in_box(child, box, iterator, user_data, lx + child->x, ly + child->y)) {
 				return true;
 			}
 		}
 		break;
 	case WLR_SCENE_NODE_RECT:
 	case WLR_SCENE_NODE_BUFFER:
 	case WLR_SCENE_NODE_SHADOW:
 	case WLR_SCENE_NODE_BEVEL:
 	case WLR_SCENE_NODE_FRAME:
 	case WLR_SCENE_NODE_DROPLET:
 	case WLR_SCENE_NODE_OPTIMIZED_BLUR:
 	case WLR_SCENE_NODE_BLUR:;
 		struct wlr_box node_box = { .x = lx, .y = ly };
 		scene_node_get_size(node, &node_box.width, &node_box.height);
 
 		if (wlr_box_intersection(&node_box, &node_box, box) &&
 				iterator(node, lx, ly, user_data)) {
 			return true;
 		}
 		break;
 	}
 
 	return false;
 }
 
 static bool scene_nodes_in_box(struct wlr_scene_node *node, struct wlr_box *box,
 		scene_node_box_iterator_func_t iterator, void *user_data) {
 	int x, y;
 	wlr_scene_node_coords(node, &x, &y);
 
 	return _scene_nodes_in_box(node, box, iterator, user_data, x, y);
 }
 
 static pixman_region32_t create_corner_location_region(struct fx_corner_radii corners, int x, int y, int width, int height) {
 	pixman_region32_t corner_region;
 	pixman_region32_init(&corner_region);
 	if (corners.top_left) {
 		pixman_region32_union_rect(&corner_region, &corner_region, x, y, corners.top_left, corners.top_left);
 	}
 
 	if (corners.top_right) {
 		pixman_region32_union_rect(&corner_region, &corner_region, x + (width - corners.top_right), y,
 			corners.top_right, corners.top_right);
 	}
 
 	if (corners.bottom_left) {
 		pixman_region32_union_rect(&corner_region, &corner_region, x, y + (height - corners.bottom_left),
 			corners.bottom_left, corners.bottom_left);
 	}
 
 	if (corners.bottom_right) {
 		pixman_region32_union_rect(&corner_region, &corner_region,
 			x + (width - corners.bottom_right), y + (height - corners.bottom_right),
 			corners.bottom_right, corners.bottom_right);
 	}
 
 	return corner_region;
 }
 
 static void scene_node_opaque_region(struct wlr_scene_node *node, int x, int y,
 		pixman_region32_t *opaque) {
 	int width, height;
 	scene_node_get_size(node, &width, &height);
 
 	if (node->type == WLR_SCENE_NODE_RECT) {
 		struct wlr_scene_rect *scene_rect = wlr_scene_rect_from_node(node);
 		if (scene_rect->color[3] != 1 || scene_rect->fade_inset > 0) {
 			return;
 		}
 
 		pixman_region32_fini(opaque);
 		pixman_region32_init_rect(opaque, x, y, width, height);
 
 		// subtract corners from opaque region
 		if (!fx_corner_radii_is_empty(&scene_rect->corners)) {
 			pixman_region32_t corners = create_corner_location_region(scene_rect->corners, x, y, width, height);
 			pixman_region32_subtract(opaque, opaque, &corners);
 			pixman_region32_fini(&corners);
 		}
 
 		// subtract clipped area from opaque region
 		if (!wlr_box_empty(&scene_rect->clipped_region.area)) {
 			struct wlr_box *clipped = &scene_rect->clipped_region.area;
 			pixman_region32_t clipped_region;
 			pixman_region32_init_rect(&clipped_region, clipped->x + x, clipped->y + y,
 					clipped->width, clipped->height);
 			pixman_region32_subtract(opaque, opaque, &clipped_region);
 			pixman_region32_fini(&clipped_region);
 		}
 		return;
 	} else if (node->type == WLR_SCENE_NODE_BUFFER) {
 		struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
 
 		if (!scene_buffer->buffer) {
 			return;
 		}
 
 		if (scene_buffer->opacity != 1) {
 			return;
 		}
 
 		if (!scene_buffer->buffer_is_opaque) {
 			pixman_region32_copy(opaque, &scene_buffer->opaque_region);
 			pixman_region32_intersect_rect(opaque, opaque, 0, 0, width, height);
 			pixman_region32_translate(opaque, x, y);
 		} else {
 			pixman_region32_fini(opaque);
 			pixman_region32_init_rect(opaque, x, y, width, height);
 		}
 
 		// subtract the corners from the opaque region
 		if (!fx_corner_radii_is_empty(&scene_buffer->corners)) {
 			pixman_region32_t corners = create_corner_location_region(scene_buffer->corners, x, y, width, height);
 			pixman_region32_subtract(opaque, opaque, &corners);
 			pixman_region32_fini(&corners);
 		}
 
 		return;
 	} else if (node->type == WLR_SCENE_NODE_SHADOW) {
 		// TODO: test & handle case of blur sigma = 0 and color[3] = 1?
 		return;
 	} else if (node->type == WLR_SCENE_NODE_BEVEL
 			|| node->type == WLR_SCENE_NODE_FRAME
 			|| node->type == WLR_SCENE_NODE_DROPLET
 			|| node->type == WLR_SCENE_NODE_OPTIMIZED_BLUR
 			|| node->type == WLR_SCENE_NODE_BLUR) {
 		// Always transparent (the droplet is opaque inside its silhouette
 		// but never box-shaped, so it must not occlude as a box).
 		return;
 	}
 
 	pixman_region32_fini(opaque);
 	pixman_region32_init_rect(opaque, x, y, width, height);
 }
 
 struct scene_update_data {
 	struct wlr_scene_node *updated_node;
 	pixman_region32_t *visible;
 	const pixman_region32_t *update_region;
 	struct wlr_box update_box;
 	struct wl_list *outputs;
 	bool calculate_visibility;
 	bool restack_xwayland_surfaces;
 
 #if WLR_HAS_XWAYLAND
 	struct wlr_xwayland_surface *restack_above;
 #endif
 	bool blur_frozen;
 	bool content_update;
 };
 
 static uint32_t region_area(const pixman_region32_t *region) {
 	uint32_t area = 0;
 
 	int nrects;
 	pixman_box32_t *rects = pixman_region32_rectangles(region, &nrects);
 	for (int i = 0; i < nrects; ++i) {
 		area += (rects[i].x2 - rects[i].x1) * (rects[i].y2 - rects[i].y1);
 	}
 
 	return area;
 }
 
 static void scale_region(pixman_region32_t *region, float scale, bool round_up) {
 	wlr_region_scale(region, region, scale);
 
 	if (round_up && floor(scale) != scale) {
 		wlr_region_expand(region, region, 1);
 	}
 }
 
 struct render_data {
 	enum wl_output_transform transform;
 	float scale;
 	struct wlr_box logical;
 	int trans_width, trans_height;
 
 	struct wlr_scene_output *output;
 
 	struct wlr_render_pass *render_pass;
 	pixman_region32_t damage;
 };
 
 static void logical_to_buffer_coords(pixman_region32_t *region, const struct render_data *data,
 		bool round_up) {
 	enum wl_output_transform transform = wlr_output_transform_invert(data->transform);
 	scale_region(region, data->scale, round_up);
 	wlr_region_transform(region, region, transform, data->trans_width, data->trans_height);
 }
 
 static void output_to_buffer_coords(pixman_region32_t *damage, struct wlr_output *output) {
 	int width, height;
 	wlr_output_transformed_resolution(output, &width, &height);
 
 	wlr_region_transform(damage, damage,
 		wlr_output_transform_invert(output->transform), width, height);
 }
 
 static int scale_length(int length, int offset, float scale) {
 	return round((offset + length) * scale) - round(offset * scale);
 }
 
 static void scale_box(struct wlr_box *box, float scale) {
 	box->width = scale_length(box->width, box->x, scale);
 	box->height = scale_length(box->height, box->y, scale);
 	box->x = round(box->x * scale);
 	box->y = round(box->y * scale);
 }
 
 static void transform_output_box(struct wlr_box *box, const struct render_data *data) {
 	enum wl_output_transform transform = wlr_output_transform_invert(data->transform);
 	scale_box(box, data->scale);
 	wlr_box_transform(box, box, transform, data->trans_width, data->trans_height);
 }
 
 /* Whether a node renders with the scene's desk sub-pixel offset: any
  * ancestor is one of the scene's desk trees. */
 static bool scene_node_has_desk_offset(struct wlr_scene *scene, struct wlr_scene_node *node) {
 	for (struct wlr_scene_tree *t = node->parent; t != NULL; t = t->node.parent) {
 		for (int i = 0; i < WLR_SCENE_DESK_TREES; i++) {
 			if (scene->desk_trees[i] == t) {
 				return true;
 			}
 		}
 	}
 	return false;
 }
 
 /* The desk offset in an output's device px (each 0 or negative). Only a
  * NORMAL transform is shifted: on a rotated output the vector would need
  * rotating too, and no cce output is rotated. */
 static void scene_desk_offset_px(struct wlr_scene *scene, float scale,
 		enum wl_output_transform transform, int *dx, int *dy) {
 	*dx = 0;
 	*dy = 0;
 	if (transform != WL_OUTPUT_TRANSFORM_NORMAL) {
 		return;
 	}
 	*dx = (int)lround(scene->desk_sub_x * scale);
 	*dy = (int)lround(scene->desk_sub_y * scale);
 }
 
 static void scene_output_damage(struct wlr_scene_output *scene_output,
 		const pixman_region32_t *damage) {
 	struct wlr_output *output = scene_output->output;
 
 	pixman_region32_t clipped;
 	pixman_region32_init(&clipped);
 	pixman_region32_intersect_rect(&clipped, damage, 0, 0, output->width, output->height);
 
 	// A desk shifted by the sub-pixel offset draws its nodes up to one
 	// device px away from where their layout boxes say; widen the damage
 	// by that shift so the drawn pixels are always inside it.
 	{
 		int dx, dy;
 		scene_desk_offset_px(scene_output->scene, output->scale, output->transform, &dx, &dy);
 		if (dx != 0 || dy != 0) {
 			pixman_region32_t shifted;
 			pixman_region32_init(&shifted);
 			pixman_region32_copy(&shifted, &clipped);
 			pixman_region32_translate(&shifted, dx, dy);
 			pixman_region32_union(&clipped, &clipped, &shifted);
 			pixman_region32_intersect_rect(&clipped, &clipped, 0, 0, output->width, output->height);
 			pixman_region32_fini(&shifted);
 		}
 	}
 
 	if (!pixman_region32_empty(&clipped)) {
 		wlr_output_schedule_frame(scene_output->output);
 		wlr_damage_ring_add(&scene_output->damage_ring, &clipped);
 
 		pixman_region32_union(&scene_output->pending_commit_damage,
 			&scene_output->pending_commit_damage, &clipped);
 	}
 
 	pixman_region32_fini(&clipped);
 }
 
 static void scene_output_damage_whole(struct wlr_scene_output *scene_output) {
 	struct wlr_output *output = scene_output->output;
 
 	pixman_region32_t damage;
 	pixman_region32_init_rect(&damage, 0, 0, output->width, output->height);
 	scene_output_damage(scene_output, &damage);
 	pixman_region32_fini(&damage);
 }
 
 static void scene_damage_outputs(struct wlr_scene *scene, const pixman_region32_t *damage) {
 	if (pixman_region32_empty(damage)) {
 		return;
 	}
 
 	struct wlr_scene_output *scene_output;
 	wl_list_for_each(scene_output, &scene->outputs, link) {
 		pixman_region32_t output_damage;
 		pixman_region32_init(&output_damage);
 		pixman_region32_copy(&output_damage, damage);
 		pixman_region32_translate(&output_damage,
 			-scene_output->x, -scene_output->y);
 		scale_region(&output_damage, scene_output->output->scale, true);
 		output_to_buffer_coords(&output_damage, scene_output->output);
 		scene_output_damage(scene_output, &output_damage);
 		pixman_region32_fini(&output_damage);
 	}
 }
 
 static void update_node_update_outputs(struct wlr_scene_node *node,
 		struct wl_list *outputs, struct wlr_scene_output *ignore,
 		struct wlr_scene_output *force) {
 	if (node->type != WLR_SCENE_NODE_BUFFER) {
 		return;
 	}
 
 	struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
 
 	uint32_t largest_overlap = 0;
 	struct wlr_scene_output *old_primary_output = scene_buffer->primary_output;
 	scene_buffer->primary_output = NULL;
 
 	size_t count = 0;
 	uint64_t active_outputs = 0;
 
 	if (!pixman_region32_empty(&node->visible)) {
 		uint32_t visible_area = region_area(&node->visible);
 
 		// let's update the outputs in two steps:
 		//  - the primary outputs
 		//  - the enter/leave signals
 		// This ensures that the enter/leave signals can rely on the primary output
 		// to have a reasonable value. Otherwise, they may get a value that's in
 		// the middle of a calculation.
 		struct wlr_scene_output *scene_output;
 		wl_list_for_each(scene_output, outputs, link) {
 			if (scene_output == ignore) {
 				continue;
 			}
 
 			if (!scene_output->output->enabled) {
 				continue;
 			}
 
 			struct wlr_box output_box = {
 				.x = scene_output->x,
 				.y = scene_output->y,
 			};
 			wlr_output_effective_resolution(scene_output->output,
 				&output_box.width, &output_box.height);
 
 			pixman_region32_t intersection;
 			pixman_region32_init(&intersection);
 			pixman_region32_intersect_rect(&intersection, &node->visible,
 				output_box.x, output_box.y, output_box.width, output_box.height);
 			uint32_t overlap = region_area(&intersection);
 			pixman_region32_fini(&intersection);
 
 			// If the overlap accounts for less than 10% of the visible node area,
 			// ignore this output
 			if (overlap >= 0.1 * visible_area) {
 				if (overlap >= largest_overlap) {
 					largest_overlap = overlap;
 					scene_buffer->primary_output = scene_output;
 				}
 
 				active_outputs |= 1ull << scene_output->index;
 				count++;
 			}
 		}
 	}
 
 	// NOT cleared on a primary_output change (cce): clearing it defeats the
 	// duplicate-suppression memcmp in scene_buffer_send_dmabuf_feedback, and
 	// the options it compares already carry everything a change here could
 	// affect — main_renderer and scanout_primary_output. Composition feedback
 	// is {renderer, NULL} whichever output is primary, so clearing only ever
 	// forced a byte-identical resend.
 	//
 	// Each resend costs the client a format-table fd, and Mesa parks those on
 	// its private WSI queues until the next acquire/present — so an idle,
 	// damage-driven window banks one per resend and never drains. Measured on
 	// a live session before this change: one enter+exit of the overview added
 	// 67 fds to every long-lived client at once, against a 1024 soft limit.
 
 	uint64_t old_active = scene_buffer->active_outputs;
 	scene_buffer->active_outputs = active_outputs;
 
 	struct wlr_scene_output *scene_output;
 	wl_list_for_each(scene_output, outputs, link) {
 		uint64_t mask = 1ull << scene_output->index;
 		bool intersects = active_outputs & mask;
 		bool intersects_before = old_active & mask;
 
 		if (intersects && !intersects_before) {
 			wl_signal_emit_mutable(&scene_buffer->events.output_enter, scene_output);
 		} else if (!intersects && intersects_before) {
 			wl_signal_emit_mutable(&scene_buffer->events.output_leave, scene_output);
 		}
 	}
 
 	// if there are active outputs on this node, we should always have a primary
 	// output
 	assert(!scene_buffer->active_outputs || scene_buffer->primary_output);
 
 	// Skip output update event if nothing was updated
 	if (old_active == active_outputs &&
 			(!force || ((1ull << force->index) & ~active_outputs)) &&
 			old_primary_output == scene_buffer->primary_output) {
 		return;
 	}
 
 	struct wlr_scene_output *outputs_array[64];
 	struct wlr_scene_outputs_update_event event = {
 		.active = outputs_array,
 		.size = count,
 	};
 
 	size_t i = 0;
 	wl_list_for_each(scene_output, outputs, link) {
 		if (~active_outputs & (1ull << scene_output->index)) {
 			continue;
 		}
 
 		assert(i < count);
 		outputs_array[i++] = scene_output;
 	}
 
 	wl_signal_emit_mutable(&scene_buffer->events.outputs_update, &event);
 }
 
 #if WLR_HAS_XWAYLAND
 static struct wlr_xwayland_surface *scene_node_try_get_managed_xwayland_surface(
 		struct wlr_scene_node *node) {
 	if (node->type != WLR_SCENE_NODE_BUFFER) {
 		return NULL;
 	}
 
 	struct wlr_scene_buffer *buffer_node = wlr_scene_buffer_from_node(node);
 	struct wlr_scene_surface *surface_node = wlr_scene_surface_try_from_buffer(buffer_node);
 	if (!surface_node) {
 		return NULL;
 	}
 
 	struct wlr_xwayland_surface *xwayland_surface =
 		wlr_xwayland_surface_try_from_wlr_surface(surface_node->surface);
 	if (!xwayland_surface || xwayland_surface->override_redirect) {
 		return NULL;
 	}
 
 	return xwayland_surface;
 }
 
 static void restack_xwayland_surface(struct wlr_scene_node *node,
 		struct wlr_box *box, struct scene_update_data *data) {
 	struct wlr_xwayland_surface *xwayland_surface =
 		scene_node_try_get_managed_xwayland_surface(node);
 	if (!xwayland_surface) {
 		return;
 	}
 
 	// ensure this node is entirely inside the update region. If not, we can't
 	// restack this node since we're not considering the whole thing.
 	if (wlr_box_contains_box(&data->update_box, box)) {
 		if (data->restack_above) {
 			wlr_xwayland_surface_restack(xwayland_surface, data->restack_above, XCB_STACK_MODE_BELOW);
 		} else {
 			wlr_xwayland_surface_restack(xwayland_surface, NULL, XCB_STACK_MODE_ABOVE);
 		}
 	}
 
 	data->restack_above = xwayland_surface;
 }
 #endif
 
 static bool cce_scene_blur_debug(void) {
 	static int enabled = -1;
 	if (enabled < 0) {
 		const char *v = getenv("CCE_BLUR_DEBUG");
 		enabled = v && *v && strcmp(v, "0") != 0;
 	}
 	return enabled;
 }
 
 static bool scene_node_is_below(struct wlr_scene_node *a, struct wlr_scene_node *b) {
 	if (a == b) {
 		return false;
 	}
 
 	struct wlr_scene_node *chain_a[64];
 	struct wlr_scene_node *chain_b[64];
 	int len_a = 0;
 	int len_b = 0;
 
 	struct wlr_scene_node *curr = a;
 	while (curr && len_a < 64) {
 		chain_a[len_a++] = curr;
 		curr = curr->parent ? &curr->parent->node : NULL;
 	}
 
 	curr = b;
 	while (curr && len_b < 64) {
 		chain_b[len_b++] = curr;
 		curr = curr->parent ? &curr->parent->node : NULL;
 	}
 
 	int idx_a = len_a - 1;
 	int idx_b = len_b - 1;
 
 	if (chain_a[idx_a] != chain_b[idx_b]) {
 		return false;
 	}
 
 	while (idx_a >= 0 && idx_b >= 0 && chain_a[idx_a] == chain_b[idx_b]) {
 		idx_a--;
 		idx_b--;
 	}
 
 	if (idx_a < 0) {
 		return true;
 	}
 	if (idx_b < 0) {
 		return false;
 	}
 
 	struct wlr_scene_tree *lca = wlr_scene_tree_from_node(chain_a[idx_a + 1]);
 	struct wlr_scene_node *child;
 	wl_list_for_each(child, &lca->children, link) {
 		if (child == chain_a[idx_a]) {
 			return true;
 		}
 		if (child == chain_b[idx_b]) {
 			return false;
 		}
 	}
 
 	return false;
 }
 
 static bool scene_node_update_iterator(struct wlr_scene_node *node,
 		int lx, int ly, void *_data) {
 	struct scene_update_data *data = _data;
 
 	if (node->type == WLR_SCENE_NODE_OPTIMIZED_BLUR) {
 		struct wlr_scene_optimized_blur *scene_blur = wlr_scene_optimized_blur_from_node(node);
 		// A frozen scene ignores nodes MOVING below (the backdrop travelling
 		// with a pan); content changing below still re-bakes.
 		if (data->updated_node && (!data->blur_frozen || data->content_update) &&
 				scene_node_is_below(data->updated_node, node)) {
 			if (data->blur_frozen && cce_scene_blur_debug()) {
 				wlr_log(WLR_INFO, "[scenefx] frozen: content dirty from node type %d (%dx%d) below opt %dx%d",
 					data->updated_node->type, data->update_box.width, data->update_box.height,
 					scene_blur->width, scene_blur->height);
 			}
 			scene_blur->dirty = true;
 		}
 		if (scene_blur->dirty) {
 			// Restore the visible region back to default, without any opaque
 			// regions. This ensures that all nodes below are fully re-rendered
 			// and not culled by above nodes.
 			pixman_region32_clear(data->visible);
 			pixman_region32_copy(data->visible, data->update_region);
 		}
 	}
 
 	struct wlr_box box = { .x = lx, .y = ly };
 	scene_node_get_size(node, &box.width, &box.height);
 
 	pixman_region32_subtract(&node->visible, &node->visible, data->update_region);
 	pixman_region32_union(&node->visible, &node->visible, data->visible);
 	pixman_region32_intersect_rect(&node->visible, &node->visible,
 		lx, ly, box.width, box.height);
 
 	if (data->calculate_visibility) {
 		pixman_region32_t opaque;
 		pixman_region32_init(&opaque);
 		scene_node_opaque_region(node, lx, ly, &opaque);
 		pixman_region32_subtract(data->visible, data->visible, &opaque);
 		pixman_region32_fini(&opaque);
 	}
 
 	update_node_update_outputs(node, data->outputs, NULL, NULL);
 #if WLR_HAS_XWAYLAND
 	if (data->restack_xwayland_surfaces) {
 		restack_xwayland_surface(node, &box, data);
 	}
 #endif
 
 	return false;
 }
 
 static void scene_node_visibility(struct wlr_scene_node *node,
 		pixman_region32_t *visible) {
 	if (!node->enabled) {
 		return;
 	}
 
 	if (node->type == WLR_SCENE_NODE_TREE) {
 		struct wlr_scene_tree *scene_tree = wlr_scene_tree_from_node(node);
 		struct wlr_scene_node *child;
 		wl_list_for_each(child, &scene_tree->children, link) {
 			scene_node_visibility(child, visible);
 		}
 		return;
 	}
 
 	pixman_region32_union(visible, visible, &node->visible);
 }
 
 static void scene_node_bounds(struct wlr_scene_node *node,
 		int x, int y, pixman_region32_t *visible) {
 	if (!node->enabled) {
 		return;
 	}
 
 	if (node->type == WLR_SCENE_NODE_TREE) {
 		struct wlr_scene_tree *scene_tree = wlr_scene_tree_from_node(node);
 		struct wlr_scene_node *child;
 		wl_list_for_each(child, &scene_tree->children, link) {
 			scene_node_bounds(child, x + child->x, y + child->y, visible);
 		}
 		return;
 	}
 
 	int width, height;
 	scene_node_get_size(node, &width, &height);
 	pixman_region32_union_rect(visible, visible, x, y, width, height);
 }
 
 static void scene_update_region(struct wlr_scene *scene,
 		struct wlr_scene_node *updated_node,
 		const pixman_region32_t *update_region, bool content_update) {
 	pixman_region32_t visible;
 	pixman_region32_init(&visible);
 	pixman_region32_copy(&visible, update_region);
 
 	struct pixman_box32 *region_box = pixman_region32_extents(update_region);
 	struct scene_update_data data = {
 		.updated_node = updated_node,
 		.visible = &visible,
 		.update_region = update_region,
 		.update_box = {
 			.x = region_box->x1,
 			.y = region_box->y1,
 			.width = region_box->x2 - region_box->x1,
 			.height = region_box->y2 - region_box->y1,
 		},
 		.outputs = &scene->outputs,
 		.calculate_visibility = scene->calculate_visibility,
 		.restack_xwayland_surfaces = scene->restack_xwayland_surfaces,
 		.blur_frozen = scene->blur_frozen,
 		.content_update = content_update,
 	};
 
 	// update node visibility and output enter/leave events
 	scene_nodes_in_box(&scene->tree.node, &data.update_box, scene_node_update_iterator, &data);
 
 	pixman_region32_fini(&visible);
 }
 
 static void scene_node_cleanup_when_disabled(struct wlr_scene_node *node,
 		bool xwayland_restack, struct wl_list *outputs) {
 	if (node->type == WLR_SCENE_NODE_TREE) {
 		struct wlr_scene_tree *scene_tree = wlr_scene_tree_from_node(node);
 		struct wlr_scene_node *child;
 		wl_list_for_each(child, &scene_tree->children, link) {
 			if (!child->enabled) {
 				continue;
 			}
 
 			scene_node_cleanup_when_disabled(child, xwayland_restack, outputs);
 		}
 		return;
 	}
 
 	pixman_region32_clear(&node->visible);
 	update_node_update_outputs(node, outputs, NULL, NULL);
 
 #if WLR_HAS_XWAYLAND
 	if (xwayland_restack) {
 		struct wlr_xwayland_surface *xwayland_surface =
 			scene_node_try_get_managed_xwayland_surface(node);
 		if (!xwayland_surface) {
 			return;
 		}
 
 		wlr_xwayland_surface_restack(xwayland_surface, NULL, XCB_STACK_MODE_BELOW);
 	}
 #endif
 }
 
 /**
  * Updates the nodes visibility, xwayland restacking, send leave/enter events
  * and damages the screen. The damage region is used to not only damage the
  * screen, but to direct the update logic to only update certain parts of the
  * screen and not the whole thing. If a NULL damage is given, the damage is
  * assumed to be the previous nodes visibility.
  *
  * Currently, the only usage for an explicit damage is for update scenarios where
  * the scene node might be enabled/disabled. If the scene node is disabled, the
  * update logic will ignore the node. This is normally desirable as most update
  * scenarios like updating the color or whatever. However, it's not what we want
  * when disabling the node. Note that reparenting the node could lead to the node
  * being reparented to a disabled super tree.
  */
 static void scene_node_update(struct wlr_scene_node *node,
 		pixman_region32_t *damage) {
 	struct wlr_scene *scene = scene_node_get_root(node);
 	// Explicit damage means the node's CONTENT changed (a buffer commit, a
 	// disable); NULL means a property or position change.
 	bool content_update = damage != NULL;
 
 	int x, y;
 	if (!wlr_scene_node_coords(node, &x, &y)) {
 		// We assume explicit damage on a disabled tree means the node was just
 		// disabled.
 		if (damage) {
 			scene_node_cleanup_when_disabled(node, scene->restack_xwayland_surfaces, &scene->outputs);
 
 			scene_update_region(scene, node, damage, content_update);
 			scene_damage_outputs(scene, damage);
 			pixman_region32_fini(damage);
 		}
 
 		return;
 	}
 
 	pixman_region32_t visible;
 	if (!damage) {
 		pixman_region32_init(&visible);
 		scene_node_visibility(node, &visible);
 		damage = &visible;
 	}
 
 	pixman_region32_t update_region;
 	pixman_region32_init(&update_region);
 	pixman_region32_copy(&update_region, damage);
 	scene_node_bounds(node, x, y, &update_region);
 
 	scene_update_region(scene, node, &update_region, content_update);
 	pixman_region32_fini(&update_region);
 
 	scene_node_visibility(node, damage);
 	scene_damage_outputs(scene, damage);
 	pixman_region32_fini(damage);
 }
 
 struct wlr_scene_rect *wlr_scene_rect_create(struct wlr_scene_tree *parent,
 		int width, int height, const float color[static 4]) {
 	assert(parent);
 	assert(width >= 0 && height >= 0);
 
 	struct wlr_scene_rect *scene_rect = calloc(1, sizeof(*scene_rect));
 	if (scene_rect == NULL) {
 		return NULL;
 	}
 	scene_node_init(&scene_rect->node, WLR_SCENE_NODE_RECT, parent);
 
 	scene_rect->width = width;
 	scene_rect->height = height;
 	memcpy(scene_rect->color, color, sizeof(scene_rect->color));
 	scene_rect->corners = (struct fx_corner_radii){0};
 	scene_rect->accepts_input = true;
 	scene_rect->clipped_region = clipped_region_get_default();
 
 	scene_node_update(&scene_rect->node, NULL);
 
 	return scene_rect;
 }
 
 void wlr_scene_rect_set_size(struct wlr_scene_rect *rect, int width, int height) {
 	if (rect->width == width && rect->height == height) {
 		return;
 	}
 
 	assert(width >= 0 && height >= 0);
 
 	scene_node_update(&rect->node, NULL);
 	rect->width = width;
 	rect->height = height;
 	scene_node_update(&rect->node, NULL);
 }
 
 void wlr_scene_rect_set_color(struct wlr_scene_rect *rect, const float color[static 4]) {
 	if (memcmp(rect->color, color, sizeof(rect->color)) == 0) {
 		return;
 	}
 
 	memcpy(rect->color, color, sizeof(rect->color));
 	scene_node_update(&rect->node, NULL);
 }
 
 void wlr_scene_rect_set_fade_inset(struct wlr_scene_rect *rect, int fade_inset) {
 	if (rect->fade_inset == fade_inset) {
 		return;
 	}
 
 	rect->fade_inset = fade_inset;
 	scene_node_update(&rect->node, NULL);
 }
 
 static void scene_buffer_handle_buffer_release(struct wl_listener *listener,
 		void *data) {
 	struct wlr_scene_buffer *scene_buffer =
 		wl_container_of(listener, scene_buffer, buffer_release);
 
 	scene_buffer->buffer = NULL;
 	wl_list_remove(&scene_buffer->buffer_release.link);
 	wl_list_init(&scene_buffer->buffer_release.link);
 }
 
 static void scene_buffer_set_buffer(struct wlr_scene_buffer *scene_buffer,
 		struct wlr_buffer *buffer) {
 	wl_list_remove(&scene_buffer->buffer_release.link);
 	wl_list_init(&scene_buffer->buffer_release.link);
 	if (scene_buffer->own_buffer) {
 		wlr_buffer_unlock(scene_buffer->buffer);
 	}
 	scene_buffer->buffer = NULL;
 	scene_buffer->own_buffer = false;
 	scene_buffer->buffer_width = scene_buffer->buffer_height = 0;
 	scene_buffer->buffer_is_opaque = false;
 
 	if (!buffer) {
 		return;
 	}
 
 	scene_buffer->own_buffer = true;
 	scene_buffer->buffer = wlr_buffer_lock(buffer);
 	scene_buffer->buffer_width = buffer->width;
 	scene_buffer->buffer_height = buffer->height;
 	scene_buffer->buffer_is_opaque = wlr_buffer_is_opaque(buffer);
 
 	scene_buffer->buffer_release.notify = scene_buffer_handle_buffer_release;
 	wl_signal_add(&buffer->events.release, &scene_buffer->buffer_release);
 }
 
 static void scene_buffer_handle_renderer_destroy(struct wl_listener *listener,
 		void *data) {
 	struct wlr_scene_buffer *scene_buffer = wl_container_of(listener, scene_buffer, renderer_destroy);
 	scene_buffer_set_texture(scene_buffer, NULL);
 }
 
 static void scene_buffer_set_texture(struct wlr_scene_buffer *scene_buffer,
 		struct wlr_texture *texture) {
 	wl_list_remove(&scene_buffer->renderer_destroy.link);
 	wlr_texture_destroy(scene_buffer->texture);
 	scene_buffer->texture = texture;
 
 	if (texture != NULL) {
 		scene_buffer->renderer_destroy.notify = scene_buffer_handle_renderer_destroy;
 		wl_signal_add(&texture->renderer->events.destroy, &scene_buffer->renderer_destroy);
 	} else {
 		wl_list_init(&scene_buffer->renderer_destroy.link);
 	}
 }
 
 static void scene_buffer_set_wait_timeline(struct wlr_scene_buffer *scene_buffer,
 		struct wlr_drm_syncobj_timeline *timeline, uint64_t point) {
 	wlr_drm_syncobj_timeline_unref(scene_buffer->wait_timeline);
 	if (timeline != NULL) {
 		scene_buffer->wait_timeline = wlr_drm_syncobj_timeline_ref(timeline);
 		scene_buffer->wait_point = point;
 	} else {
 		scene_buffer->wait_timeline = NULL;
 		scene_buffer->wait_point = 0;
 	}
 }
 
 inline void wlr_scene_rect_set_corner_radius(struct wlr_scene_rect *rect, int corner_radius) {
 	wlr_scene_rect_set_corner_radii(rect, corner_radii_all(corner_radius));
 }
 
 void wlr_scene_rect_set_corner_radii(struct wlr_scene_rect *rect, struct fx_corner_radii corners) {
 	if (fx_corner_radii_eq(rect->corners, corners)) {
 		return;
 	}
 
 	rect->corners = corners;
 	scene_node_update(&rect->node, NULL);
 }
 
 void wlr_scene_rect_set_clipped_region(struct wlr_scene_rect *rect,
 		struct clipped_region clipped_region) {
 	if (fx_corner_radii_eq(rect->clipped_region.corners, clipped_region.corners) &&
 			wlr_box_equal(&rect->clipped_region.area, &clipped_region.area)) {
 		return;
 	}
 
 	rect->clipped_region = clipped_region;
 	scene_node_update(&rect->node, NULL);
 }
 
 struct wlr_scene_shadow *wlr_scene_shadow_create(struct wlr_scene_tree *parent,
 		int width, int height, int corner_radius, float blur_sigma,
 		const float color [static 4]) {
 	struct wlr_scene_shadow *scene_shadow = calloc(1, sizeof(*scene_shadow));
 	if (scene_shadow == NULL) {
 		return NULL;
 	}
 	assert(parent);
 	scene_node_init(&scene_shadow->node, WLR_SCENE_NODE_SHADOW, parent);
 
 	scene_shadow->width = width;
 	scene_shadow->height = height;
 	scene_shadow->corner_radius = corner_radius;
 	scene_shadow->blur_sigma = blur_sigma;
 	memcpy(scene_shadow->color, color, sizeof(scene_shadow->color));
 	scene_shadow->clipped_region = clipped_region_get_default();
 
 	scene_node_update(&scene_shadow->node, NULL);
 
 	return scene_shadow;
 }
 
 struct wlr_scene_frame *wlr_scene_frame_create(struct wlr_scene_tree *parent,
 		int width, int height, int corner_radius, const float color[static 4]) {
 	struct wlr_scene_frame *scene_frame = calloc(1, sizeof(*scene_frame));
 	if (scene_frame == NULL) {
 		return NULL;
 	}
 	scene_node_init(&scene_frame->node, WLR_SCENE_NODE_FRAME, parent);
 
 	scene_frame->width = width;
 	scene_frame->height = height;
 	scene_frame->corner_radius = corner_radius;
 	// Shape defaults to a plain even ring; the compositor sets the real
 	// profile every frame through wlr_scene_frame_set_shape.
 	scene_frame->band = 0.0f;
 	scene_frame->band_min = 0.0f;
 	scene_frame->corner_len = 0.0f;
 	scene_frame->gap = 0.0f;
 	scene_frame->hovered = -1.0f;
 	scene_frame->swell_curve = 1.0f;
 	scene_frame->bulge = 0.0f;
 	scene_frame->buttons = 0.0f;
 	memcpy(scene_frame->color, color, sizeof(scene_frame->color));
 	memcpy(scene_frame->hover_color, color, sizeof(scene_frame->hover_color));
 
 	scene_node_update(&scene_frame->node, NULL);
 
 	return scene_frame;
 }
 
 void wlr_scene_frame_set_size(struct wlr_scene_frame *frame, int width, int height) {
 	if (frame->width == width && frame->height == height) {
 		return;
 	}
 	frame->width = width;
 	frame->height = height;
 	scene_node_update(&frame->node, NULL);
 }
 
 void wlr_scene_frame_set_corner_radius(struct wlr_scene_frame *frame, int radius) {
 	if (frame->corner_radius == radius) {
 		return;
 	}
 	frame->corner_radius = radius;
 	scene_node_update(&frame->node, NULL);
 }
 
 void wlr_scene_frame_set_shape(struct wlr_scene_frame *frame, float band,
 		float band_min, float corner_len, float gap, float swell_curve, float bulge) {
 	if (frame->band == band && frame->band_min == band_min
 			&& frame->corner_len == corner_len && frame->gap == gap
 			&& frame->swell_curve == swell_curve && frame->bulge == bulge) {
 		return;
 	}
 	frame->swell_curve = swell_curve;
 	frame->bulge = bulge;
 	frame->band = band;
 	frame->band_min = band_min;
 	frame->corner_len = corner_len;
 	frame->gap = gap;
 	scene_node_update(&frame->node, NULL);
 }
 
 void wlr_scene_frame_set_exclusion(struct wlr_scene_frame *frame,
 		const float rect[static 4]) {
 	if (memcmp(frame->exclusion, rect, sizeof(frame->exclusion)) == 0) {
 		return;
 	}
 	memcpy(frame->exclusion, rect, sizeof(frame->exclusion));
 	scene_node_update(&frame->node, NULL);
 }
 
 void wlr_scene_frame_set_buttons(struct wlr_scene_frame *frame, float buttons) {
 	if (frame->buttons == buttons) {
 		return;
 	}
 	frame->buttons = buttons;
 	scene_node_update(&frame->node, NULL);
 }
 
 void wlr_scene_frame_set_color(struct wlr_scene_frame *frame, const float color[static 4]) {
 	if (memcmp(frame->color, color, sizeof(frame->color)) == 0) {
 		return;
 	}
 	memcpy(frame->color, color, sizeof(frame->color));
 	scene_node_update(&frame->node, NULL);
 }
 
 void wlr_scene_frame_set_hover(struct wlr_scene_frame *frame, float hovered,
 		const float color[static 4]) {
 	if (frame->hovered == hovered
 			&& memcmp(frame->hover_color, color, sizeof(frame->hover_color)) == 0) {
 		return;
 	}
 	frame->hovered = hovered;
 	memcpy(frame->hover_color, color, sizeof(frame->hover_color));
 	scene_node_update(&frame->node, NULL);
 }
 
 struct wlr_scene_bevel *wlr_scene_bevel_create(struct wlr_scene_tree *parent,
 		int width, int height, int corner_radius, float thickness,
 		const float color[static 4]) {
 	struct wlr_scene_bevel *scene_bevel = calloc(1, sizeof(*scene_bevel));
 	if (scene_bevel == NULL) {
 		return NULL;
 	}
 	assert(parent);
 	scene_node_init(&scene_bevel->node, WLR_SCENE_NODE_BEVEL, parent);
 
 	scene_bevel->width = width;
 	scene_bevel->height = height;
 	scene_bevel->corner_radius = corner_radius;
 	scene_bevel->thickness = thickness;
 	// Default light: top-left, matching the DE's shadow convention.
 	scene_bevel->light_dir[0] = -0.7071f;
 	scene_bevel->light_dir[1] = -0.7071f;
 	scene_bevel->light_intensity = 1.0f;
 	scene_bevel->shade_intensity = 1.0f;
 	scene_bevel->shoulder = 0.5f;
 	memcpy(scene_bevel->color, color, sizeof(scene_bevel->color));
 
 	scene_node_update(&scene_bevel->node, NULL);
 
 	return scene_bevel;
 }
 
 void wlr_scene_bevel_set_size(struct wlr_scene_bevel *bevel, int width, int height) {
 	if (bevel->width == width && bevel->height == height) {
 		return;
 	}
 	bevel->width = width;
 	bevel->height = height;
 	scene_node_update(&bevel->node, NULL);
 }
 
 void wlr_scene_bevel_set_corner_radius(struct wlr_scene_bevel *bevel, int radius) {
 	if (bevel->corner_radius == radius) {
 		return;
 	}
 	bevel->corner_radius = radius;
 	scene_node_update(&bevel->node, NULL);
 }
 
 void wlr_scene_bevel_set_thickness(struct wlr_scene_bevel *bevel, float thickness) {
 	if (bevel->thickness == thickness) {
 		return;
 	}
 	bevel->thickness = thickness;
 	scene_node_update(&bevel->node, NULL);
 }
 
 void wlr_scene_bevel_set_light(struct wlr_scene_bevel *bevel, float dir_x, float dir_y,
 		float light_intensity, float shade_intensity) {
 	if (bevel->light_dir[0] == dir_x && bevel->light_dir[1] == dir_y
 			&& bevel->light_intensity == light_intensity
 			&& bevel->shade_intensity == shade_intensity) {
 		return;
 	}
 	bevel->light_dir[0] = dir_x;
 	bevel->light_dir[1] = dir_y;
 	bevel->light_intensity = light_intensity;
 	bevel->shade_intensity = shade_intensity;
 	scene_node_update(&bevel->node, NULL);
 }
 
 void wlr_scene_bevel_set_shoulder(struct wlr_scene_bevel *bevel, float shoulder) {
 	if (bevel->shoulder == shoulder) {
 		return;
 	}
 	bevel->shoulder = shoulder;
 	scene_node_update(&bevel->node, NULL);
 }
 
 struct wlr_scene_droplet *wlr_scene_droplet_create(struct wlr_scene_tree *parent,
 		int width, int height) {
 	struct wlr_scene_droplet *droplet = calloc(1, sizeof(*droplet));
 	if (droplet == NULL) {
 		return NULL;
 	}
 	assert(parent);
 	scene_node_init(&droplet->node, WLR_SCENE_NODE_DROPLET, parent);
 
 	droplet->width = width;
 	droplet->height = height;
 	droplet->curve = 2.0f;
 
 	scene_node_update(&droplet->node, NULL);
 
 	return droplet;
 }
 
 void wlr_scene_droplet_set_size(struct wlr_scene_droplet *droplet, int width, int height) {
 	if (droplet->width == width && droplet->height == height) {
 		return;
 	}
 	droplet->width = width;
 	droplet->height = height;
 	scene_node_update(&droplet->node, NULL);
 }
 
 void wlr_scene_droplet_set_silhouette(struct wlr_scene_droplet *droplet,
 		float attach_r, float sheet_r, float bow_rise, float blend_k, float curve) {
 	if (droplet->attach_r == attach_r && droplet->sheet_r == sheet_r
 			&& droplet->bow_rise == bow_rise && droplet->blend_k == blend_k
 			&& droplet->curve == curve) {
 		return;
 	}
 	droplet->attach_r = attach_r;
 	droplet->sheet_r = sheet_r;
 	droplet->bow_rise = bow_rise;
 	droplet->blend_k = blend_k;
 	droplet->curve = curve;
 	scene_node_update(&droplet->node, NULL);
 }
 
 void wlr_scene_droplet_set_lens(struct wlr_scene_droplet *droplet,
 		float band_px, float refr, float ghost) {
 	if (droplet->band_px == band_px && droplet->refr == refr
 			&& droplet->ghost == ghost) {
 		return;
 	}
 	droplet->band_px = band_px;
 	droplet->refr = refr;
 	droplet->ghost = ghost;
 	scene_node_update(&droplet->node, NULL);
 }
 
 void wlr_scene_droplet_set_compress(struct wlr_scene_droplet *droplet,
 		float ceil, float knee, bool invert) {
 	if (droplet->compress_ceil == ceil && droplet->compress_knee == knee
 			&& droplet->compress_invert == invert) {
 		return;
 	}
 	droplet->compress_ceil = ceil;
 	droplet->compress_knee = knee;
 	droplet->compress_invert = invert;
 	scene_node_update(&droplet->node, NULL);
 }
 
 void wlr_scene_bevel_set_color(struct wlr_scene_bevel *bevel, const float color[static 4]) {
 	if (memcmp(bevel->color, color, sizeof(bevel->color)) == 0) {
 		return;
 	}
 	memcpy(bevel->color, color, sizeof(bevel->color));
 	scene_node_update(&bevel->node, NULL);
 }
 
 void wlr_scene_bevel_set_focus(struct wlr_scene_bevel *bevel, float focus, float sharpness,
 		const float color[static 3]) {
 	if (bevel->focus == focus && bevel->focus_sharpness == sharpness &&
 			memcmp(bevel->focus_color, color, sizeof(bevel->focus_color)) == 0) {
 		return;
 	}
 	bevel->focus = focus;
 	bevel->focus_sharpness = sharpness;
 	memcpy(bevel->focus_color, color, sizeof(bevel->focus_color));
 	scene_node_update(&bevel->node, NULL);
 }
 
 void wlr_scene_shadow_set_size(struct wlr_scene_shadow *shadow, int width, int height) {
 	if (shadow->width == width && shadow->height == height) {
 		return;
 	}
 
 	shadow->width = width;
 	shadow->height = height;
 	scene_node_update(&shadow->node, NULL);
 }
 
 void wlr_scene_shadow_set_corner_radius(struct wlr_scene_shadow *shadow, int corner_radius) {
 	if (shadow->corner_radius == corner_radius) {
 		return;
 	}
 
 	shadow->corner_radius = corner_radius;
 	scene_node_update(&shadow->node, NULL);
 }
 
 void wlr_scene_shadow_set_blur_sigma(struct wlr_scene_shadow *shadow, float blur_sigma) {
 	if (shadow->blur_sigma == blur_sigma) {
 		return;
 	}
 
 	shadow->blur_sigma = blur_sigma;
 	scene_node_update(&shadow->node, NULL);
 }
 
 void wlr_scene_shadow_set_color(struct wlr_scene_shadow *shadow, const float color[static 4]) {
 	if (memcmp(shadow->color, color, sizeof(shadow->color)) == 0) {
 		return;
 	}
 
 	memcpy(shadow->color, color, sizeof(shadow->color));
 	scene_node_update(&shadow->node, NULL);
 }
 
 void wlr_scene_shadow_set_clipped_region(struct wlr_scene_shadow *shadow,
 		struct clipped_region clipped_region) {
 	if (fx_corner_radii_eq(shadow->clipped_region.corners, clipped_region.corners) &&
 			wlr_box_equal(&shadow->clipped_region.area, &clipped_region.area)) {
 		return;
 	}
 
 	shadow->clipped_region = clipped_region;
 	scene_node_update(&shadow->node, NULL);
 }
 
 static void mark_all_optimized_blur_nodes_dirty(struct wlr_scene_node *node) {
 	if (node->type == WLR_SCENE_NODE_OPTIMIZED_BLUR) {
 		struct wlr_scene_optimized_blur *scene_blur = wlr_scene_optimized_blur_from_node(node);
 		wlr_scene_optimized_blur_mark_dirty(scene_blur);
 	} else if (node->type == WLR_SCENE_NODE_TREE) {
 		struct wlr_scene_tree *scene_tree = wlr_scene_tree_from_node(node);
 		struct wlr_scene_node *child;
 		wl_list_for_each(child, &scene_tree->children, link) {
 			mark_all_optimized_blur_nodes_dirty(child);
 		}
 	}
 }
 
 struct wlr_scene_blur *wlr_scene_blur_create(struct wlr_scene_tree *parent,
 	   int width, int height) {
 	struct wlr_scene_blur *blur = calloc(1, sizeof(*blur));
 	if (blur == NULL) {
 		return NULL;
 	}
 	assert(parent);
 	scene_node_init(&blur->node, WLR_SCENE_NODE_BLUR, parent);
 
 	blur->alpha = 1.0f;
 	blur->strength = 1.0f;
 	blur->clipped_region = (struct clipped_region){0};
 	blur->corners = corner_radii_all(0);
 	blur->should_only_blur_bottom_layer = false;
 	blur->transparency_mask_source = linked_node_init();
 	blur->width = width;
 	blur->height = height;
 
 	scene_node_update(&blur->node, NULL);
 
 	return blur;
 }
 
 void wlr_scene_blur_set_size(struct wlr_scene_blur *blur, int width, int height) {
 	if (blur->width == width && blur->height == height) {
 		return;
 	}
 
 	blur->width = width;
 	blur->height = height;
 
 	scene_node_update(&blur->node, NULL);
 }
 
 inline void wlr_scene_blur_set_corner_radius(struct wlr_scene_blur *blur, int corner_radius) {
 	wlr_scene_blur_set_corner_radii(blur, corner_radii_all(corner_radius));
 }
 
 void wlr_scene_blur_set_corner_radii(struct wlr_scene_blur *blur, struct fx_corner_radii corners) {
 	if (fx_corner_radii_eq(blur->corners, corners)) {
 		return;
 	}
 
 	blur->corners = corners;
 	scene_node_update(&blur->node, NULL);
 }
 
 void wlr_scene_blur_set_should_only_blur_bottom_layer(struct wlr_scene_blur *blur,
 	bool should_only_blur_bottom_layer) {
 	if (blur->should_only_blur_bottom_layer == should_only_blur_bottom_layer) {
 		return;
 	}
 
 	blur->should_only_blur_bottom_layer = should_only_blur_bottom_layer;
 	scene_node_update(&blur->node, NULL);
 }
 
 void wlr_scene_blur_set_transparency_mask_source(struct wlr_scene_blur *blur,
        struct wlr_scene_buffer *source) {
 	if (source == NULL && blur->transparency_mask_source.link == NULL) {
 		return;
 	}
 
 	if (source != NULL && linked_nodes_are_linked(&blur->transparency_mask_source, &source->blur)) {
 		return;
 	}
 
 	linked_node_destroy(&blur->transparency_mask_source);
 
 	if (source != NULL) {
 		linked_node_destroy(&source->blur);
 		linked_node_init_link(&blur->transparency_mask_source, &source->blur);
 	}
 
 	scene_node_update(&blur->node, NULL);
 }
 
 struct wlr_scene_buffer *wlr_scene_blur_get_transparency_mask_source(
 	struct wlr_scene_blur *blur) {
 	struct linked_node *node = linked_nodes_get_sibling(&blur->transparency_mask_source);
 	if (node == NULL) {
 		return NULL;
 	}
 
 	struct wlr_scene_buffer *output = wl_container_of(node, output, blur);
 	return output;
 }
 
 void wlr_scene_blur_set_alpha(struct wlr_scene_blur *blur, float alpha) {
 	if (blur->alpha == alpha) {
 		return;
 	}
 
 	blur->alpha = alpha;
 	scene_node_update(&blur->node, NULL);
 }
 
 void wlr_scene_blur_set_strength(struct wlr_scene_blur *blur, float strength) {
 	if (blur->strength == strength) {
 		return;
 	}
 
 	blur->strength = strength;
 	scene_node_update(&blur->node, NULL);
 }
 
 void wlr_scene_blur_set_compress(struct wlr_scene_blur *blur,
 		float ceil, float knee, bool invert) {
 	if (blur->compress_ceil == ceil && blur->compress_knee == knee
 			&& blur->compress_invert == invert) {
 		return;
 	}
 	blur->compress_ceil = ceil;
 	blur->compress_knee = knee;
 	blur->compress_invert = invert;
 	scene_node_update(&blur->node, NULL);
 }
 
 void wlr_scene_blur_set_clipped_region(struct wlr_scene_blur *blur,
 		struct clipped_region clipped_region) {
 	if (fx_corner_radii_eq(blur->clipped_region.corners, clipped_region.corners) &&
 		wlr_box_equal(&blur->clipped_region.area, &clipped_region.area)) {
 		return;
 	}
 
 	blur->clipped_region = clipped_region;
 	scene_node_update(&blur->node, NULL);
 }
 
 void wlr_scene_set_blur_data(struct wlr_scene *scene, int num_passes,
 		int radius, float noise, float brightness, float contrast, float saturation) {
 	struct blur_data *buff_data = &scene->blur_data;
 	if (buff_data->num_passes == num_passes
 			&& buff_data->radius == radius
 			&& buff_data->noise == noise
 			&& buff_data->brightness == brightness
 			&& buff_data->contrast == contrast
 			&& buff_data->saturation == saturation) {
 		return;
 	}
 
 	buff_data->num_passes = num_passes;
 	buff_data->radius = radius;
 	buff_data->noise = noise;
 	buff_data->brightness = brightness;
 	buff_data->contrast = contrast;
 	buff_data->saturation = saturation;
 
 	mark_all_optimized_blur_nodes_dirty(&scene->tree.node);
 	scene_node_update(&scene->tree.node, NULL);
 }
 
 void wlr_scene_set_blur_num_passes(struct wlr_scene *scene, int num_passes) {
 	struct blur_data *buff_data = &scene->blur_data;
 	if (buff_data->num_passes == num_passes) {
 		return;
 	}
 	buff_data->num_passes = num_passes;
 	mark_all_optimized_blur_nodes_dirty(&scene->tree.node);
 	scene_node_update(&scene->tree.node, NULL);
 }
 
 void wlr_scene_set_blur_radius(struct wlr_scene *scene, int radius) {
 	struct blur_data *buff_data = &scene->blur_data;
 	if (buff_data->radius == radius) {
 		return;
 	}
 	buff_data->radius = radius;
 	mark_all_optimized_blur_nodes_dirty(&scene->tree.node);
 	scene_node_update(&scene->tree.node, NULL);
 }
 
 void wlr_scene_set_blur_noise(struct wlr_scene *scene, float noise) {
 	struct blur_data *buff_data = &scene->blur_data;
 	if (buff_data->noise == noise) {
 		return;
 	}
 	buff_data->noise = noise;
 	mark_all_optimized_blur_nodes_dirty(&scene->tree.node);
 	scene_node_update(&scene->tree.node, NULL);
 }
 
 void wlr_scene_set_blur_brightness(struct wlr_scene *scene, float brightness) {
 	struct blur_data *buff_data = &scene->blur_data;
 	if (buff_data->brightness == brightness) {
 		return;
 	}
 	buff_data->brightness = brightness;
 	mark_all_optimized_blur_nodes_dirty(&scene->tree.node);
 	scene_node_update(&scene->tree.node, NULL);
 }
 
 void wlr_scene_set_blur_contrast(struct wlr_scene *scene, float contrast) {
 	struct blur_data *buff_data = &scene->blur_data;
 	if (buff_data->contrast == contrast) {
 		return;
 	}
 	buff_data->contrast = contrast;
 	mark_all_optimized_blur_nodes_dirty(&scene->tree.node);
 	scene_node_update(&scene->tree.node, NULL);
 }
 
 void wlr_scene_set_blur_saturation(struct wlr_scene *scene, float saturation) {
 	struct blur_data *buff_data = &scene->blur_data;
 	if (buff_data->saturation == saturation) {
 		return;
 	}
 	buff_data->saturation = saturation;
 	mark_all_optimized_blur_nodes_dirty(&scene->tree.node);
 	scene_node_update(&scene->tree.node, NULL);
 }
 
 struct wlr_scene_optimized_blur *wlr_scene_optimized_blur_create(
 		struct wlr_scene_tree *parent, int width, int height) {
 	struct wlr_scene_optimized_blur *scene_blur = calloc(1, sizeof(*scene_blur));
 	if (scene_blur == NULL) {
 		return NULL;
 	}
 	assert(parent);
 	scene_node_init(&scene_blur->node, WLR_SCENE_NODE_OPTIMIZED_BLUR, parent);
 
 	scene_blur->width = width;
 	scene_blur->height = height;
 	pixman_region32_init(&scene_blur->baked_region);
 	pixman_region32_init(&scene_blur->edge_region);
 	// Start dirty so the first render pass bakes the cache; scene_entry_render
 	// only re-bakes when dirty (re-baking on undamaged frames samples stale
 	// pass->buffer content, ghosting whatever was composited above the node).
 	scene_blur->dirty = true;
 
 	scene_node_update(&scene_blur->node, NULL);
 
 	return scene_blur;
 }
 
 void wlr_scene_optimized_blur_set_size(struct wlr_scene_optimized_blur *blur_node,
 		int width, int height) {
 	assert(blur_node);
 	if (blur_node->width == width && blur_node->height == height) {
 		return;
 	}
 
 	blur_node->width = width;
 	blur_node->height = height;
 
 	// While the scene is frozen (a camera gesture in flight, see
 	// wlr_scene.blur_frozen) a resize keeps its bake: the anchored render
 	// path bakes only the strips a grown node newly exposes, and a shrunk
 	// one needs nothing. Re-baking here made every frame of a zoom re-bake
 	// every blur, which the freeze exists to avoid; the thaw re-bakes once.
 	struct wlr_scene *scene = scene_node_get_root(&blur_node->node);
 	if (scene != NULL && scene->blur_frozen && blur_node->baked) {
 		scene_node_update(&blur_node->node, NULL);
 		return;
 	}
 
 	wlr_scene_optimized_blur_mark_dirty(blur_node);
 }
 
 void wlr_scene_optimized_blur_mark_dirty(struct wlr_scene_optimized_blur *blur_node) {
 	// Skip re-rendering the optimized blur if the blur node is disabled
 	if (blur_node && !blur_node->node.enabled) {
 		return;
 	}
 
 	blur_node->dirty = true;
 
 	scene_node_update(&blur_node->node, NULL);
 }
 
 struct wlr_scene_buffer *wlr_scene_buffer_create(struct wlr_scene_tree *parent,
 		struct wlr_buffer *buffer) {
 	struct wlr_scene_buffer *scene_buffer = calloc(1, sizeof(*scene_buffer));
 	if (scene_buffer == NULL) {
 		return NULL;
 	}
 	assert(parent);
 	scene_node_init(&scene_buffer->node, WLR_SCENE_NODE_BUFFER, parent);
 
 	wl_signal_init(&scene_buffer->events.outputs_update);
 	wl_signal_init(&scene_buffer->events.output_enter);
 	wl_signal_init(&scene_buffer->events.output_leave);
 	wl_signal_init(&scene_buffer->events.output_sample);
 	wl_signal_init(&scene_buffer->events.frame_done);
 
 	pixman_region32_init(&scene_buffer->opaque_region);
 	wl_list_init(&scene_buffer->buffer_release.link);
 	wl_list_init(&scene_buffer->renderer_destroy.link);
 	scene_buffer->opacity = 1;
 
 	scene_buffer->corners = corner_radii_none();
 
 	scene_buffer->blur = linked_node_init();
 
 	scene_buffer_set_buffer(scene_buffer, buffer);
 	scene_node_update(&scene_buffer->node, NULL);
 
 	return scene_buffer;
 }
 
 void wlr_scene_buffer_set_buffer_with_options(struct wlr_scene_buffer *scene_buffer,
 		struct wlr_buffer *buffer, const struct wlr_scene_buffer_set_buffer_options *options) {
 	const struct wlr_scene_buffer_set_buffer_options default_options = {0};
 	if (options == NULL) {
 		options = &default_options;
 	}
 
 	// specifying a region for a NULL buffer doesn't make sense. We need to know
 	// about the buffer to scale the buffer local coordinates down to scene
 	// coordinates.
 	assert(buffer || !options->damage);
 
 	bool mapped = buffer != NULL;
 	bool prev_mapped = scene_buffer->buffer != NULL || scene_buffer->texture != NULL;
 
 	if (!mapped && !prev_mapped) {
 		// unmapping already unmapped buffer - noop
 		return;
 	}
 
 	// if this node used to not be mapped or its previous displayed
 	// buffer region will be different from what the new buffer would
 	// produce we need to update the node.
 	bool update = mapped != prev_mapped;
 	if (buffer != NULL && scene_buffer->dst_width == 0 && scene_buffer->dst_height == 0) {
 		update = update || scene_buffer->buffer_width != buffer->width ||
 			scene_buffer->buffer_height != buffer->height;
 	}
 
 	// If this is a buffer change, check if it's a single pixel buffer.
 	// Cache that so we can still apply rendering optimisations even when
 	// the original buffer has been freed after texture upload.
 	if (buffer != scene_buffer->buffer) {
 		scene_buffer->is_single_pixel_buffer = false;
 		struct wlr_client_buffer *client_buffer = NULL;
 		if (buffer != NULL) {
 			client_buffer = wlr_client_buffer_get(buffer);
 		}
 		if (client_buffer != NULL && client_buffer->source != NULL) {
 			struct wlr_single_pixel_buffer_v1 *single_pixel_buffer =
 				wlr_single_pixel_buffer_v1_try_from_buffer(client_buffer->source);
 			if (single_pixel_buffer != NULL) {
 				scene_buffer->is_single_pixel_buffer = true;
 				scene_buffer->single_pixel_buffer_color[0] = single_pixel_buffer->r;
 				scene_buffer->single_pixel_buffer_color[1] = single_pixel_buffer->g;
 				scene_buffer->single_pixel_buffer_color[2] = single_pixel_buffer->b;
 				scene_buffer->single_pixel_buffer_color[3] = single_pixel_buffer->a;
 			}
 		}
 	}
 
 	scene_buffer_set_buffer(scene_buffer, buffer);
 	scene_buffer_set_texture(scene_buffer, NULL);
 	scene_buffer_set_wait_timeline(scene_buffer,
 		options->wait_timeline, options->wait_point);
 
 	if (update) {
 		scene_node_update(&scene_buffer->node, NULL);
 		// updating the node will already damage the whole node for us. Return
 		// early to not damage again
 		return;
 	}
 
 	int lx, ly;
 	if (!wlr_scene_node_coords(&scene_buffer->node, &lx, &ly)) {
 		return;
 	}
 
 	pixman_region32_t fallback_damage;
 	pixman_region32_init_rect(&fallback_damage, 0, 0, buffer->width, buffer->height);
 	const pixman_region32_t *damage = options->damage;
 	if (!damage) {
 		damage = &fallback_damage;
 	}
 
 	struct wlr_fbox box = scene_buffer->src_box;
 	if (wlr_fbox_empty(&box)) {
 		box.x = 0;
 		box.y = 0;
 		box.width = buffer->width;
 		box.height = buffer->height;
 	}
 
 	wlr_fbox_transform(&box, &box, scene_buffer->transform,
 		buffer->width, buffer->height);
 
 	float scale_x, scale_y;
 	if (scene_buffer->dst_width || scene_buffer->dst_height) {
 		scale_x = scene_buffer->dst_width / box.width;
 		scale_y = scene_buffer->dst_height / box.height;
 	} else {
 		scale_x = buffer->width / box.width;
 		scale_y = buffer->height / box.height;
 	}
 
 	pixman_region32_t trans_damage;
 	pixman_region32_init(&trans_damage);
 	wlr_region_transform(&trans_damage, damage,
 		scene_buffer->transform, buffer->width, buffer->height);
 	pixman_region32_intersect_rect(&trans_damage, &trans_damage,
 		box.x, box.y, box.width, box.height);
 	pixman_region32_translate(&trans_damage, -box.x, -box.y);
 
 	struct wlr_scene *scene = scene_node_get_root(&scene_buffer->node);
 	struct wlr_scene_output *scene_output;
 	wl_list_for_each(scene_output, &scene->outputs, link) {
 		float output_scale = scene_output->output->scale;
 		float output_scale_x = output_scale * scale_x;
 		float output_scale_y = output_scale * scale_y;
 		pixman_region32_t output_damage;
 		pixman_region32_init(&output_damage);
 		wlr_region_scale_xy(&output_damage, &trans_damage,
 			output_scale_x, output_scale_y);
 
 		// One output pixel will match (buffer_scale_x)x(buffer_scale_y) buffer pixels.
 		// If the buffer is upscaled on the given axis (output_scale_* > 1.0,
 		// buffer_scale_* < 1.0), its contents will bleed into adjacent
 		// (ceil(output_scale_* / 2)) output pixels because of linear filtering.
 		// Additionally, if the buffer is downscaled (output_scale_* < 1.0,
 		// buffer_scale_* > 1.0), and one output pixel matches a non-integer number of
 		// buffer pixels, its contents will bleed into neighboring output pixels.
 		// Handle both cases by computing buffer_scale_{x,y} and checking if they are
 		// integer numbers; ceilf() is used to ensure that the distance is at least 1.
 		float buffer_scale_x = 1.0f / output_scale_x;
 		float buffer_scale_y = 1.0f / output_scale_y;
 		int dist_x = floor(buffer_scale_x) != buffer_scale_x ?
 			(int)ceilf(output_scale_x / 2.0f) : 0;
 		int dist_y = floor(buffer_scale_y) != buffer_scale_y ?
 			(int)ceilf(output_scale_y / 2.0f) : 0;
 		// TODO: expand with per-axis distances
 		wlr_region_expand(&output_damage, &output_damage,
 			dist_x >= dist_y ? dist_x : dist_y);
 
 		pixman_region32_t cull_region;
 		pixman_region32_init(&cull_region);
 		pixman_region32_copy(&cull_region, &scene_buffer->node.visible);
 		scale_region(&cull_region, output_scale, true);
 		pixman_region32_translate(&cull_region, -lx * output_scale, -ly * output_scale);
 		pixman_region32_intersect(&output_damage, &output_damage, &cull_region);
 		pixman_region32_fini(&cull_region);
 
 		pixman_region32_translate(&output_damage,
 			(int)round((lx - scene_output->x) * output_scale),
 			(int)round((ly - scene_output->y) * output_scale));
 		output_to_buffer_coords(&output_damage, scene_output->output);
 		scene_output_damage(scene_output, &output_damage);
 		pixman_region32_fini(&output_damage);
 	}
 
 	pixman_region32_fini(&trans_damage);
 	pixman_region32_fini(&fallback_damage);
 }
 
 void wlr_scene_buffer_set_buffer_with_damage(struct wlr_scene_buffer *scene_buffer,
 		struct wlr_buffer *buffer, const pixman_region32_t *damage) {
 	const struct wlr_scene_buffer_set_buffer_options options = {
 		.damage = damage,
 	};
 	wlr_scene_buffer_set_buffer_with_options(scene_buffer, buffer, &options);
 }
 
 void wlr_scene_buffer_set_buffer(struct wlr_scene_buffer *scene_buffer,
 		struct wlr_buffer *buffer)  {
 	wlr_scene_buffer_set_buffer_with_options(scene_buffer, buffer, NULL);
 }
 
 void wlr_scene_buffer_set_geometry_pinned(struct wlr_scene_buffer *scene_buffer,
 		bool pinned) {
 	scene_buffer->geometry_pinned = pinned;
 }
 
 void wlr_scene_buffer_set_opaque_region(struct wlr_scene_buffer *scene_buffer,
 		const pixman_region32_t *region) {
 	if (scene_buffer->geometry_pinned) {
 		return;
 	}
 	wlr_scene_buffer_set_opaque_region_pinned(scene_buffer, region);
 }
 
 void wlr_scene_buffer_set_opaque_region_pinned(struct wlr_scene_buffer *scene_buffer,
 		const pixman_region32_t *region) {
 	if (pixman_region32_equal(&scene_buffer->opaque_region, region)) {
 		return;
 	}
 
 	pixman_region32_copy(&scene_buffer->opaque_region, region);
 
 	int x, y;
 	if (!wlr_scene_node_coords(&scene_buffer->node, &x, &y)) {
 		return;
 	}
 
 	pixman_region32_t update_region;
 	pixman_region32_init(&update_region);
 	scene_node_bounds(&scene_buffer->node, x, y, &update_region);
 	scene_update_region(scene_node_get_root(&scene_buffer->node), &scene_buffer->node, &update_region, true);
 	pixman_region32_fini(&update_region);
 }
 
 void wlr_scene_buffer_set_source_box(struct wlr_scene_buffer *scene_buffer,
 		const struct wlr_fbox *box) {
 	if (wlr_fbox_equal(&scene_buffer->src_box, box)) {
 		return;
 	}
 
 	if (box != NULL) {
 		assert(box->x >= 0 && box->y >= 0 && box->width >= 0 && box->height >= 0);
 		scene_buffer->src_box = *box;
 	} else {
 		scene_buffer->src_box = (struct wlr_fbox){0};
 	}
 
 	scene_node_update(&scene_buffer->node, NULL);
 }
 
 void wlr_scene_buffer_set_dest_size(struct wlr_scene_buffer *scene_buffer,
 		int width, int height) {
 	if (scene_buffer->geometry_pinned) {
 		return;
 	}
 	wlr_scene_buffer_set_dest_size_pinned(scene_buffer, width, height);
 }
 
 void wlr_scene_buffer_set_dest_size_pinned(struct wlr_scene_buffer *scene_buffer,
 		int width, int height) {
 	if (scene_buffer->dst_width == width && scene_buffer->dst_height == height) {
 		return;
 	}
 
 	assert(width >= 0 && height >= 0);
 	scene_node_update(&scene_buffer->node, NULL);
 	scene_buffer->dst_width = width;
 	scene_buffer->dst_height = height;
 	scene_node_update(&scene_buffer->node, NULL);
 }
 
 void wlr_scene_buffer_set_transform(struct wlr_scene_buffer *scene_buffer,
 		enum wl_output_transform transform) {
 	if (scene_buffer->transform == transform) {
 		return;
 	}
 
 	scene_node_update(&scene_buffer->node, NULL);
 	scene_buffer->transform = transform;
 	scene_node_update(&scene_buffer->node, NULL);
 }
 
 // Frame-callback delivery tracer. A demand-driven client cannot repaint while
 // it waits on a frame callback, so a surface silently skipped by the visible
 // gate below stalls until the next output frame that does reach it. Set
 // CCE_FRAME_DEBUG=1 to trace every buffer, or CCE_FRAME_DEBUG=WxH (the dst
 // size, e.g. 504x1032) to trace one window — the filtered form is what to use
 // while measuring, since tracing every buffer adds writes to the very thread
 // whose latency is under test.
 static bool cce_frame_debug_match(int dst_width, int dst_height) {
 	static bool initialized = false;
 	static bool enabled = false;
 	static int want_w = -1, want_h = -1;
 	if (!initialized) {
 		const char *value = getenv("CCE_FRAME_DEBUG");
 		if (value && *value) {
 			enabled = true;
 			// "WxH" matches one size exactly; a bare "W" matches on width only
 			// (a window's height can change under it); anything else traces all.
 			int parsed = sscanf(value, "%dx%d", &want_w, &want_h);
 			if (parsed == 1) {
 				want_h = -1;
 			} else if (parsed != 2) {
 				want_w = want_h = -1;
 			}
 		}
 		initialized = true;
 	}
 	if (!enabled) {
 		return false;
 	}
 	if (want_w < 0) {
 		return true;
 	}
 	return dst_width == want_w && (want_h < 0 || dst_height == want_h);
 }
 
 // Same time base as cce-ui's CCE_PRESENT_DEBUG and cce-system-interface's
 // CCE_HOVER_DEBUG (epoch ms mod 100000) so the three logs interleave directly.
 static int64_t cce_now_ms(void) {
 	struct timespec ts;
 	clock_gettime(CLOCK_REALTIME, &ts);
 	return ((int64_t)ts.tv_sec * 1000 + ts.tv_nsec / 1000000) % 100000;
 }
 
 void wlr_scene_buffer_send_frame_done(struct wlr_scene_buffer *scene_buffer,
 		struct wlr_scene_frame_done_event *event) {
 	bool visible = !pixman_region32_empty(&scene_buffer->node.visible);
 	if (cce_frame_debug_match(scene_buffer->dst_width, scene_buffer->dst_height)) {
 		pixman_box32_t *extents = pixman_region32_extents(&scene_buffer->node.visible);
 		// listeners: is anything wired to turn this signal into a client callback?
 		// (wlr_scene_surface registers one; zero means the emit goes nowhere.)
 		// committed_cb / pending_cb: does the surface actually hold a frame callback
 		// for wlr_surface_send_frame_done to fire? A request stuck in `pending` means
 		// the client asked but the compositor has not applied that commit yet — which
 		// separates "compositor drops it" from "client's request never landed".
 		int listeners = wl_list_length(&scene_buffer->events.frame_done.listener_list);
 		int committed_cb = -1, pending_cb = -1;
 		struct wlr_scene_surface *scene_surface =
 			wlr_scene_surface_try_from_buffer(scene_buffer);
 		if (scene_surface != NULL && scene_surface->surface != NULL) {
 			committed_cb = wl_list_length(&scene_surface->surface->current.frame_callback_list);
 			pending_cb = wl_list_length(&scene_surface->surface->pending.frame_callback_list);
 		}
 		wlr_log(WLR_INFO, "[cce-frame] t=%lld send_frame_done dst=%dx%d sent=%d listeners=%d committed_cb=%d pending_cb=%d visible_extents=(%d,%d %dx%d)",
 				(long long)cce_now_ms(), scene_buffer->dst_width, scene_buffer->dst_height,
 				visible, listeners, committed_cb, pending_cb,
 				extents->x1, extents->y1,
 				extents->x2 - extents->x1, extents->y2 - extents->y1);
 	}
 	if (visible) {
 		wl_signal_emit_mutable(&scene_buffer->events.frame_done, event);
 	}
 }
 
 void wlr_scene_buffer_set_opacity(struct wlr_scene_buffer *scene_buffer,
 		float opacity) {
 	if (scene_buffer->opacity == opacity) {
 		return;
 	}
 
 	assert(opacity >= 0 && opacity <= 1);
 	scene_buffer->opacity = opacity;
 	scene_node_update(&scene_buffer->node, NULL);
 }
 
 void wlr_scene_buffer_set_filter_mode(struct wlr_scene_buffer *scene_buffer,
 		enum wlr_scale_filter_mode filter_mode) {
 	if (scene_buffer->filter_mode == filter_mode) {
 		return;
 	}
 
 	scene_buffer->filter_mode = filter_mode;
 	scene_node_update(&scene_buffer->node, NULL);
 }
 
 void wlr_scene_buffer_set_transfer_function(struct wlr_scene_buffer *scene_buffer,
 		enum wlr_color_transfer_function transfer_function) {
 	if (scene_buffer->transfer_function == transfer_function) {
 		return;
 	}
 
 	scene_buffer->transfer_function = transfer_function;
 	scene_node_update(&scene_buffer->node, NULL);
 }
 
 void wlr_scene_buffer_set_primaries(struct wlr_scene_buffer *scene_buffer,
 		enum wlr_color_named_primaries primaries) {
 	if (scene_buffer->primaries == primaries) {
 		return;
 	}
 
 	scene_buffer->primaries = primaries;
 	scene_node_update(&scene_buffer->node, NULL);
 }
 
 void wlr_scene_buffer_set_color_encoding(struct wlr_scene_buffer *scene_buffer,
 		enum wlr_color_encoding color_encoding) {
 	if (scene_buffer->color_encoding == color_encoding) {
 		return;
 	}
 
 	scene_buffer->color_encoding = color_encoding;
 	scene_node_update(&scene_buffer->node, NULL);
 }
 
 void wlr_scene_buffer_set_color_range(struct wlr_scene_buffer *scene_buffer,
 		enum wlr_color_range color_range) {
 	if (scene_buffer->color_range == color_range) {
 		return;
 	}
 
 	scene_buffer->color_range = color_range;
 	scene_node_update(&scene_buffer->node, NULL);
 }
 
 inline void wlr_scene_buffer_set_corner_radius(struct wlr_scene_buffer *scene_buffer,
 		int radii) {
 	wlr_scene_buffer_set_corner_radii(scene_buffer, corner_radii_all(radii));
 }
 
 void wlr_scene_buffer_set_corner_radii(struct wlr_scene_buffer *scene_buffer,
 	struct fx_corner_radii corner_radii) {
 	if (fx_corner_radii_eq(scene_buffer->corners, corner_radii)) {
 		return;
 	}
 
 	scene_buffer->corners = corner_radii;
 	scene_node_update(&scene_buffer->node, NULL);
 }
 
 static struct wlr_texture *scene_buffer_get_texture(
 		struct wlr_scene_buffer *scene_buffer, struct wlr_renderer *renderer) {
 	if (scene_buffer->buffer == NULL || scene_buffer->texture != NULL) {
 		return scene_buffer->texture;
 	}
 
 	struct wlr_client_buffer *client_buffer =
 		wlr_client_buffer_get(scene_buffer->buffer);
 	if (client_buffer != NULL) {
 		return client_buffer->texture;
 	}
 
 	struct wlr_texture *texture =
 		wlr_texture_from_buffer(renderer, scene_buffer->buffer);
 	if (texture != NULL && scene_buffer->own_buffer) {
 		scene_buffer->own_buffer = false;
 		wlr_buffer_unlock(scene_buffer->buffer);
 	}
 	scene_buffer_set_texture(scene_buffer, texture);
 	return texture;
 }
 
 void scene_node_get_size(struct wlr_scene_node *node, int *width, int *height) {
 	*width = 0;
 	*height = 0;
 
 	switch (node->type) {
 	case WLR_SCENE_NODE_TREE:
 		return;
 	case WLR_SCENE_NODE_RECT:;
 		struct wlr_scene_rect *scene_rect = wlr_scene_rect_from_node(node);
 		*width = scene_rect->width;
 		*height = scene_rect->height;
 		break;
 	case WLR_SCENE_NODE_BUFFER:;
 		struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
 		if (scene_buffer->dst_width > 0 && scene_buffer->dst_height > 0) {
 			*width = scene_buffer->dst_width;
 			*height = scene_buffer->dst_height;
 		} else {
 			*width = scene_buffer->buffer_width;
 			*height = scene_buffer->buffer_height;
 			wlr_output_transform_coords(scene_buffer->transform, width, height);
 		}
 		break;
 	case WLR_SCENE_NODE_SHADOW:;
 		struct wlr_scene_shadow *scene_shadow = wlr_scene_shadow_from_node(node);
 		*width = scene_shadow->width;
 		*height = scene_shadow->height;
 		break;
 	case WLR_SCENE_NODE_BEVEL:;
 		struct wlr_scene_bevel *scene_bevel = wlr_scene_bevel_from_node(node);
 		*width = scene_bevel->width;
 		*height = scene_bevel->height;
 		break;
 	case WLR_SCENE_NODE_FRAME:;
 		struct wlr_scene_frame *scene_frame_sz = wlr_scene_frame_from_node(node);
 		*width = scene_frame_sz->width;
 		*height = scene_frame_sz->height;
 		break;
 	case WLR_SCENE_NODE_DROPLET:;
 		struct wlr_scene_droplet *scene_droplet = wlr_scene_droplet_from_node(node);
 		*width = scene_droplet->width;
 		*height = scene_droplet->height;
 		break;
 	case WLR_SCENE_NODE_OPTIMIZED_BLUR:;
 		struct wlr_scene_optimized_blur *scene_blur =
 			wlr_scene_optimized_blur_from_node(node);
 		*width = scene_blur->width;
 		*height = scene_blur->height;
 		break;
 	case WLR_SCENE_NODE_BLUR:;
 		struct wlr_scene_blur *blur = wlr_scene_blur_from_node(node);
 		*width = blur->width;
 		*height = blur->height;
 		break;
 	}
 }
 
 void wlr_scene_node_set_enabled(struct wlr_scene_node *node, bool enabled) {
 	if (node->enabled == enabled) {
 		return;
 	}
 
 	int x, y;
 	pixman_region32_t visible;
 	pixman_region32_init(&visible);
 	if (wlr_scene_node_coords(node, &x, &y)) {
 		scene_node_visibility(node, &visible);
 	}
 
 	node->enabled = enabled;
 
 	scene_node_update(node, &visible);
 }
 
 void wlr_scene_node_set_position(struct wlr_scene_node *node, int x, int y) {
 	if (node->x == x && node->y == y) {
 		return;
 	}
 
 	scene_node_update(node, NULL);
 	node->x = x;
 	node->y = y;
 	scene_node_update(node, NULL);
 }
 
 void wlr_scene_node_place_above(struct wlr_scene_node *node,
 		struct wlr_scene_node *sibling) {
 	assert(node != sibling);
 	assert(node->parent == sibling->parent);
 
 	if (node->link.prev == &sibling->link) {
 		return;
 	}
 
 	wl_list_remove(&node->link);
 	wl_list_insert(&sibling->link, &node->link);
 	scene_node_update(node, NULL);
 }
 
 void wlr_scene_node_place_below(struct wlr_scene_node *node,
 		struct wlr_scene_node *sibling) {
 	assert(node != sibling);
 	assert(node->parent == sibling->parent);
 
 	if (node->link.next == &sibling->link) {
 		return;
 	}
 
 	wl_list_remove(&node->link);
 	wl_list_insert(sibling->link.prev, &node->link);
 	scene_node_update(node, NULL);
 }
 
 void wlr_scene_node_raise_to_top(struct wlr_scene_node *node) {
 	struct wlr_scene_node *current_top = wl_container_of(
 		node->parent->children.prev, current_top, link);
 	if (node == current_top) {
 		return;
 	}
 	wlr_scene_node_place_above(node, current_top);
 }
 
 void wlr_scene_node_lower_to_bottom(struct wlr_scene_node *node) {
 	struct wlr_scene_node *current_bottom = wl_container_of(
 		node->parent->children.next, current_bottom, link);
 	if (node == current_bottom) {
 		return;
 	}
 	wlr_scene_node_place_below(node, current_bottom);
 }
 
 void wlr_scene_node_reparent(struct wlr_scene_node *node,
 		struct wlr_scene_tree *new_parent) {
 	assert(new_parent != NULL);
 
 	if (node->parent == new_parent) {
 		return;
 	}
 
 	/* Ensure that a node cannot become its own ancestor */
 	for (struct wlr_scene_tree *ancestor = new_parent; ancestor != NULL;
 			ancestor = ancestor->node.parent) {
 		assert(&ancestor->node != node);
 	}
 
 	int x, y;
 	pixman_region32_t visible;
 	pixman_region32_init(&visible);
 	if (wlr_scene_node_coords(node, &x, &y)) {
 		scene_node_visibility(node, &visible);
 	}
 
 	wl_list_remove(&node->link);
 	node->parent = new_parent;
 	wl_list_insert(new_parent->children.prev, &node->link);
 	scene_node_update(node, &visible);
 }
 
 bool wlr_scene_node_coords(struct wlr_scene_node *node,
 		int *lx_ptr, int *ly_ptr) {
 	assert(node);
 
 	int lx = 0, ly = 0;
 	bool enabled = true;
 	while (true) {
 		lx += node->x;
 		ly += node->y;
 		enabled = enabled && node->enabled;
 		if (node->parent == NULL) {
 			break;
 		}
 
 		node = &node->parent->node;
 	}
 
 	*lx_ptr = lx;
 	*ly_ptr = ly;
 	return enabled;
 }
 
 static void scene_node_for_each_scene_buffer(struct wlr_scene_node *node,
 		int lx, int ly, wlr_scene_buffer_iterator_func_t user_iterator,
 		void *user_data) {
 	if (!node->enabled) {
 		return;
 	}
 
 	lx += node->x;
 	ly += node->y;
 
 	if (node->type == WLR_SCENE_NODE_BUFFER) {
 		struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
 		user_iterator(scene_buffer, lx, ly, user_data);
 	} else if (node->type == WLR_SCENE_NODE_TREE) {
 		struct wlr_scene_tree *scene_tree = wlr_scene_tree_from_node(node);
 		struct wlr_scene_node *child;
 		wl_list_for_each(child, &scene_tree->children, link) {
 			scene_node_for_each_scene_buffer(child, lx, ly, user_iterator, user_data);
 		}
 	}
 }
 
 void wlr_scene_node_for_each_buffer(struct wlr_scene_node *node,
 		wlr_scene_buffer_iterator_func_t user_iterator, void *user_data) {
 	scene_node_for_each_scene_buffer(node, 0, 0, user_iterator, user_data);
 }
 
 struct node_at_data {
 	double lx, ly;
 	double rx, ry;
 	struct wlr_scene_node *node;
 };
 
 static bool scene_node_at_iterator(struct wlr_scene_node *node,
 		int lx, int ly, void *data) {
 	struct node_at_data *at_data = data;
 
 	double rx = at_data->lx - lx;
 	double ry = at_data->ly - ly;
 
 	if (node->type == WLR_SCENE_NODE_BUFFER) {
 		struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
 
 		// A dest-scaled surface buffer occupies dst_width x dst_height in
 		// layout space while its input region (and the coordinates its
 		// client expects) live in SURFACE-LOCAL logical space. Map the
 		// node-local point between the two before the region check, or a
 		// buffer resting at a display ratio != 1 (the desktop grid's
 		// patch, whenever the camera zoom sits off the pow2 quantization)
 		// hit-tests and reports coordinates displaced by exactly that
 		// ratio — which is how a click on a desktop item read as
 		// background, and how the press position disagreed with the drag
 		// deltas hard enough to fling the item across the canvas.
 		// Buffers displayed at their natural size (every window at rest)
 		// scale by exactly 1 here and are untouched.
 		//
 		// The ratio is between dst and the DISPLAYED region of the
 		// surface, which is the whole surface only while no clip is set.
 		// A clipped surface (wlr_scene_subsurface_tree_set_clip — how a
 		// CSD toplevel is cropped to its xdg geometry, shedding the
 		// client-side shadow margins) shows just the clip, at dst ==
 		// clip size, so it is a crop at ratio 1, not a scale — yet its
 		// surface size still differs from dst by the margins. Measuring
 		// against the whole surface inflated every pointer coordinate on
 		// such a window by (surface / geometry): a GTK3 dialog 718px
 		// tall cropped to 666 received clicks 8% below the cursor, more
 		// the further down, and the bottom band was dead because the
 		// inflated point fell outside the surface. The clip's origin is
 		// added by the surface callback below; only the extent matters
 		// here, clamped to the surface as the commit path clamps it.
 		if (scene_buffer->dst_width > 0 && scene_buffer->dst_height > 0) {
 			struct wlr_scene_surface *scene_surface =
 				wlr_scene_surface_try_from_buffer(scene_buffer);
 			if (scene_surface != NULL && scene_surface->surface != NULL) {
 				int sw = scene_surface->surface->current.width;
 				int sh = scene_surface->surface->current.height;
 				const struct wlr_box *clip = &scene_surface->clip;
 				if (!wlr_box_empty(clip)) {
 					if (clip->width < sw - clip->x) {
 						sw = clip->width;
 					} else {
 						sw -= clip->x;
 					}
 					if (clip->height < sh - clip->y) {
 						sh = clip->height;
 					} else {
 						sh -= clip->y;
 					}
 				}
 				if (sw > 0 && sh > 0 && (sw != scene_buffer->dst_width ||
 						sh != scene_buffer->dst_height)) {
 					rx = rx * sw / scene_buffer->dst_width;
 					ry = ry * sh / scene_buffer->dst_height;
 				}
 			}
 		}
 
 		if (scene_buffer->point_accepts_input &&
 				!scene_buffer->point_accepts_input(scene_buffer, &rx, &ry)) {
 			return false;
 		}
 	} else if (node->type == WLR_SCENE_NODE_RECT) {
 		struct wlr_scene_rect *rect = wlr_scene_rect_from_node(node);
 		if (!rect->accepts_input) {
 			return false;
 		} else if (!wlr_box_empty(&rect->clipped_region.area)
 				&& wlr_box_contains_point(&rect->clipped_region.area, rx, ry)) {
 			// Inside clipped region
 			return false;
 		}
 	} else if (node->type == WLR_SCENE_NODE_SHADOW
 			|| node->type == WLR_SCENE_NODE_BEVEL
 			|| node->type == WLR_SCENE_NODE_FRAME
 			|| node->type == WLR_SCENE_NODE_DROPLET
 			|| node->type == WLR_SCENE_NODE_OPTIMIZED_BLUR
 			|| node->type == WLR_SCENE_NODE_BLUR) {
 		// Disable interaction
 		return false;
 	}
 
 	at_data->rx = rx;
 	at_data->ry = ry;
 	at_data->node = node;
 	return true;
 }
 
 struct wlr_scene_node *wlr_scene_node_at(struct wlr_scene_node *node,
 		double lx, double ly, double *nx, double *ny) {
 	struct wlr_box box = {
 		.x = floor(lx),
 		.y = floor(ly),
 		.width = 1,
 		.height = 1
 	};
 
 	struct node_at_data data = {
 		.lx = lx,
 		.ly = ly
 	};
 
 	if (scene_nodes_in_box(node, &box, scene_node_at_iterator, &data)) {
 		if (nx) {
 			*nx = data.rx;
 		}
 		if (ny) {
 			*ny = data.ry;
 		}
 		return data.node;
 	}
 
 	return NULL;
 }
 
 struct render_list_entry {
 	struct wlr_scene_node *node;
 	bool highlight_transparent_region;
 	int x, y;
 };
 
 static float get_luminance_multiplier(const struct wlr_color_luminances *src_lum,
 		const struct wlr_color_luminances *dst_lum) {
 	return (dst_lum->reference / src_lum->reference) * (src_lum->max / dst_lum->max);
 }
 
 /* Bake the content below the node within one screen-space layout rect into
  * the cache, landing at `shift` (buffer px added to the screen buffer
  * coordinates: the node's anchor plus the cache margin). */
 static bool optimized_blur_bake_rect(struct fx_gles_render_pass *fx_pass,
 		struct wlr_scene *scene, const struct render_data *data,
 		const struct wlr_box *layout_rect, int shift_x, int shift_y) {
 	struct wlr_box buf = {
 		.x = (int)round((layout_rect->x - data->logical.x) * data->scale),
 		.y = (int)round((layout_rect->y - data->logical.y) * data->scale),
 		.width = (int)round(layout_rect->width * data->scale),
 		.height = (int)round(layout_rect->height * data->scale),
 	};
 	if (buf.width <= 0 || buf.height <= 0) {
 		return true;
 	}
 	const float opacity = 1.0f;
 	struct fx_render_blur_pass_options blur_options = {
 		.tex_options = {
 			.base = {
 				.transform = WL_OUTPUT_TRANSFORM_NORMAL,
 				.alpha = &opacity,
 				.blend_mode = WLR_RENDER_BLEND_MODE_NONE,
 				.dst_box = buf,
 			},
 			.clip_box = &buf,
 			.discard_transparent = false,
 			.clipped_region = {0}
 		},
 		.blur_data = &scene->blur_data,
 		.blur_strength = 1.0f,
 		.cache_shift_x = shift_x,
 		.cache_shift_y = shift_y,
 	};
 	return fx_render_pass_add_optimized_blur(fx_pass, &blur_options);
 }
 
 /* Record a just-baked rect (anchor space) in the node's region. What lay
  * within the blur's reach of an output edge — anything outside `trusted`,
  * the output inset by that reach, in the same space — sampled clamped edge
  * pixels in place of the backdrop beyond, so it also goes into
  * `edge_region` to be re-baked once it is clear of the edge. */
 static void optimized_blur_note_baked(struct wlr_scene_optimized_blur *ob,
 		const pixman_box32_t *rect, const struct wlr_box *trusted) {
 	pixman_region32_t guessed;
 	pixman_region32_init_rect(&guessed, rect->x1, rect->y1,
 		rect->x2 - rect->x1, rect->y2 - rect->y1);
 	pixman_region32_union(&ob->baked_region, &ob->baked_region, &guessed);
 	pixman_region32_subtract(&ob->edge_region, &ob->edge_region, &guessed);
 	if (trusted->width > 0 && trusted->height > 0) {
 		pixman_region32_t keep;
 		pixman_region32_init_rect(&keep, trusted->x, trusted->y,
 			trusted->width, trusted->height);
 		pixman_region32_subtract(&guessed, &guessed, &keep);
 		pixman_region32_fini(&keep);
 	}
 	pixman_region32_union(&ob->edge_region, &ob->edge_region, &guessed);
 	pixman_region32_fini(&guessed);
 }
 
 /* The optimized node's per-frame work: a full bake (anchored where the node
  * is now) when dirty, never baked, baked elsewhere, or travelled past the
  * cache margin; otherwise only the strips the node now shows that its bake
  * does not cover, landed at its existing anchor. */
 static void optimized_blur_render(struct wlr_scene *scene,
 		struct wlr_scene_optimized_blur *ob, struct wlr_scene_node *node,
 		struct fx_gles_render_pass *fx_pass, const struct render_data *data,
 		struct wlr_box dst_box) {
 	struct fx_offscreen_buffers *fbos = fx_pass->fx_offscreen_buffers;
 	if (fbos == NULL) {
 		return;
 	}
 	const int mx = fbos->cache_margin_x, my = fbos->cache_margin_y;
 	const bool normal = data->transform == WL_OUTPUT_TRANSFORM_NORMAL;
 	int cx, cy;
 	if (!wlr_scene_node_coords(node, &cx, &cy)) {
 		return;
 	}
 	struct wlr_box cur = { .x = cx, .y = cy, .width = ob->width, .height = ob->height };
 	struct wlr_box vis;
 	if (!wlr_box_intersection(&vis, &cur, &data->logical)) {
 		return;
 	}
 
 	// The output inset by the blur's sampling reach (layout px): a pixel
 	// baked outside it sampled past the output's edge.
 	const int reach = (int)ceil(blur_data_calc_size(&scene->blur_data) / data->scale);
 	const struct wlr_box trusted = {
 		.x = data->logical.x + reach,
 		.y = data->logical.y + reach,
 		.width = data->logical.width - 2 * reach,
 		.height = data->logical.height - 2 * reach,
 	};
 
 	bool full = ob->dirty || !ob->baked || ob->baked_output != data->output || !normal;
 	int dx = 0, dy = 0; // anchor-space shift, layout px: anchor - current
 	if (!full) {
 		dx = ob->baked_x - cx;
 		dy = ob->baked_y - cy;
 		double mlx = mx / data->scale, mly = my / data->scale;
 		if (vis.x + dx < data->logical.x - mlx || vis.y + dy < data->logical.y - mly ||
 				vis.x + dx + vis.width > data->logical.x + data->logical.width + mlx ||
 				vis.y + dy + vis.height > data->logical.y + data->logical.height + mly) {
 			full = true;
 		}
 	}
 
 	if (full) {
 		if (cce_scene_blur_debug()) {
 			wlr_log(WLR_INFO, "[scenefx] optimized bake full %dx%d dirty=%d baked=%d",
 				vis.width, vis.height, ob->dirty, ob->baked);
 		}
 		bool ok;
 		if (normal) {
 			ok = optimized_blur_bake_rect(fx_pass, scene, data, &vis, mx, my);
 		} else {
 			// Transformed output: the whole node in its buffer-space box,
 			// in place (no anchoring on rotated outputs).
 			const float opacity = 1.0f;
 			enum wl_output_transform transform = wlr_output_transform_invert(data->transform);
 			transform = wlr_output_transform_compose(transform, data->transform);
 			struct fx_render_blur_pass_options blur_options = {
 				.tex_options = {
 					.base = {
 						.transform = transform,
 						.alpha = &opacity,
 						.blend_mode = WLR_RENDER_BLEND_MODE_NONE,
 						.dst_box = dst_box,
 					},
 					.clip_box = &dst_box,
 					.discard_transparent = false,
 					.clipped_region = {0}
 				},
 				.blur_data = &scene->blur_data,
 				.blur_strength = 1.0f,
 				.cache_shift_x = mx,
 				.cache_shift_y = my,
 			};
 			ok = fx_render_pass_add_optimized_blur(fx_pass, &blur_options);
 		}
 		if (!ok) {
 			return;
 		}
 		ob->dirty = false;
 		ob->baked = true;
 		ob->baked_x = cx;
 		ob->baked_y = cy;
 		ob->baked_output = data->output;
 		pixman_region32_clear(&ob->baked_region);
 		pixman_region32_clear(&ob->edge_region);
 		const pixman_box32_t all = { vis.x, vis.y, vis.x + vis.width, vis.y + vis.height };
 		optimized_blur_note_baked(ob, &all, &trusted);
 		return;
 	}
 
 	// Anchored: what the node shows now, in anchor space, minus what the
 	// cache already holds for it — plus what it holds only as an edge guess
 	// that has since moved clear of every edge (a pan carrying a window
 	// that hung off the output inward: without this, the band along the
 	// old edge kept its clamped blur, a seam of smeared backdrop).
 	const struct wlr_box trusted_a = {
 		.x = trusted.x + dx, .y = trusted.y + dy,
 		.width = trusted.width, .height = trusted.height,
 	};
 	pixman_region32_t need, uncovered, stale;
 	pixman_region32_init_rect(&need, vis.x + dx, vis.y + dy, vis.width, vis.height);
 	pixman_region32_init(&uncovered);
 	pixman_region32_subtract(&uncovered, &need, &ob->baked_region);
 	pixman_region32_init(&stale);
 	if (trusted.width > 0 && trusted.height > 0) {
 		pixman_region32_intersect_rect(&stale, &ob->edge_region,
 			trusted_a.x, trusted_a.y, trusted_a.width, trusted_a.height);
 		pixman_region32_intersect(&stale, &stale, &need);
 		if (cce_scene_blur_debug() && pixman_region32_not_empty(&stale)) {
 			const pixman_box32_t *e = pixman_region32_extents(&stale);
 			wlr_log(WLR_INFO, "[scenefx] optimized re-bake edge guess %dx%d at (%d, %d), node travel (%d, %d)",
 				e->x2 - e->x1, e->y2 - e->y1, e->x1, e->y1, -dx, -dy);
 		}
 		pixman_region32_union(&uncovered, &uncovered, &stale);
 	}
 	pixman_region32_fini(&stale);
 	int n = 0;
 	const pixman_box32_t *rects = pixman_region32_rectangles(&uncovered, &n);
 	const int shift_x = (int)round(dx * data->scale) + mx;
 	const int shift_y = (int)round(dy * data->scale) + my;
 	for (int i = 0; i < n; i++) {
 		// The strip in screen space (where its content is being composited
 		// this frame); it lands in the cache at the node's anchor.
 		struct wlr_box r = {
 			.x = rects[i].x1 - dx, .y = rects[i].y1 - dy,
 			.width = rects[i].x2 - rects[i].x1, .height = rects[i].y2 - rects[i].y1,
 		};
 		if (optimized_blur_bake_rect(fx_pass, scene, data, &r, shift_x, shift_y)) {
 			optimized_blur_note_baked(ob, &rects[i], &trusted_a);
 		}
 	}
 	pixman_region32_fini(&need);
 	pixman_region32_fini(&uncovered);
 }
 
 static void scene_entry_render(struct render_list_entry *entry, const struct render_data *data) {
 	struct wlr_scene_node *node = entry->node;
 	struct fx_gles_render_pass *fx_pass = fx_get_render_pass(data->render_pass);
 
 	// Desk nodes draw shifted by the sub-pixel offset (device px); every
 	// box and region derived from the node's layout position below gets
 	// the same shift, so the node stays self-consistent and only its
 	// placement against unshifted layers (bars, fullscreen) is off by it.
 	int desk_dx = 0, desk_dy = 0;
 	if (scene_node_has_desk_offset(data->output->scene, node)) {
 		scene_desk_offset_px(data->output->scene, data->scale, data->transform, &desk_dx, &desk_dy);
 	}
 
 	pixman_region32_t render_region;
 	pixman_region32_init(&render_region);
 	pixman_region32_copy(&render_region, &node->visible);
 	pixman_region32_translate(&render_region, -data->logical.x, -data->logical.y);
 	logical_to_buffer_coords(&render_region, data, true);
 	pixman_region32_translate(&render_region, desk_dx, desk_dy);
 	pixman_region32_intersect(&render_region, &render_region, &data->damage);
 	if (pixman_region32_empty(&render_region)) {
 		pixman_region32_fini(&render_region);
 		return;
 	}
 
 	// CCE_BLUR_DEBUG: why is this blur node rendering — its box, the slice
 	// inside this frame's damage, and the damage extents.
 	if (node->type == WLR_SCENE_NODE_BLUR && cce_scene_blur_debug()) {
 		const pixman_box32_t *v = pixman_region32_extents(&node->visible);
 		const pixman_box32_t *r = pixman_region32_extents(&render_region);
 		const pixman_box32_t *d = pixman_region32_extents(&data->damage);
 		wlr_log(WLR_INFO, "[scenefx] blur entry visible=(%d,%d)-(%d,%d) render=(%d,%d)-(%d,%d) damage=(%d,%d)-(%d,%d) rects=%d",
 			v->x1, v->y1, v->x2, v->y2, r->x1, r->y1, r->x2, r->y2,
 			d->x1, d->y1, d->x2, d->y2, pixman_region32_n_rects(&data->damage));
 	}
 
 	int x = entry->x - data->logical.x;
 	int y = entry->y - data->logical.y;
 
 	struct wlr_box dst_box = {
 		.x = x,
 		.y = y,
 	};
 	scene_node_get_size(node, &dst_box.width, &dst_box.height);
 	transform_output_box(&dst_box, data);
 	dst_box.x += desk_dx;
 	dst_box.y += desk_dy;
 
 	pixman_region32_t opaque;
 	pixman_region32_init(&opaque);
 	scene_node_opaque_region(node, x, y, &opaque);
 	logical_to_buffer_coords(&opaque, data, false);
 	pixman_region32_translate(&opaque, desk_dx, desk_dy);
 	pixman_region32_subtract(&opaque, &render_region, &opaque);
 
 	enum wl_output_transform node_transform =
 		wlr_output_transform_compose(WL_OUTPUT_TRANSFORM_NORMAL, data->transform);
 
 	struct wlr_scene *scene = data->output->scene;
 	switch (node->type) {
 	case WLR_SCENE_NODE_TREE:
 		assert(false);
 		break;
 	case WLR_SCENE_NODE_RECT:;
 		struct wlr_scene_rect *scene_rect = wlr_scene_rect_from_node(node);
 		struct fx_corner_radii rect_corners = scene_rect->corners;
 
 		fx_corner_radii_transform(node_transform, &rect_corners);
 
 		struct wlr_box rect_clipped_region_box = scene_rect->clipped_region.area;
 		struct fx_corner_radii rect_clipped_corners = scene_rect->clipped_region.corners;
 
 		// Node relative -> Root relative
 		rect_clipped_region_box.x += x;
 		rect_clipped_region_box.y += y;
 
 		transform_output_box(&rect_clipped_region_box, data);
 		rect_clipped_region_box.x += desk_dx;
 		rect_clipped_region_box.y += desk_dy;
 		fx_corner_radii_transform(node_transform, &rect_clipped_corners);
 
 		struct fx_render_rect_options rect_options = {
 			.base = {
 				.box = dst_box,
 				.color = {
 					.r = scene_rect->color[0],
 					.g = scene_rect->color[1],
 					.b = scene_rect->color[2],
 					.a = scene_rect->color[3],
 				},
 				.clip = &render_region,
 				.blend_mode = (scene_rect->color[3] == 1.0f && fx_corner_radii_is_empty(&rect_corners) && scene_rect->fade_inset == 0) ?
 					WLR_RENDER_BLEND_MODE_NONE : WLR_RENDER_BLEND_MODE_PREMULTIPLIED,
 			},
 			.clipped_region = {
 				.area = rect_clipped_region_box,
 				.corners = fx_corner_radii_scale(rect_clipped_corners, data->scale),
 			},
 		};
 
 		// TODO: Use the base wlr_render_pass_add_rect as a fast-path in the future
 		if (!fx_corner_radii_is_empty(&rect_corners) || scene_rect->fade_inset > 0) {
 			// fade_inset is wire-encoded as inset_px * 1000 + fade_mode:
 			// scale only the inset part — multiplying the whole encoding
 			// also multiplied the mode digit (quadratic became gaussian on
 			// a 2x output).
 			int fade_enc = scene_rect->fade_inset;
 			int fade_px = (int)((float)(fade_enc / 1000) * data->scale + 0.5f);
 			struct fx_render_rounded_rect_options rounded_rect_options = {
 				.base = rect_options.base,
 				.corners = fx_corner_radii_scale(rect_corners, data->scale),
 				.clipped_region = rect_options.clipped_region,
 				.fade_inset = fade_px * 1000 + fade_enc % 1000,
 			};
 			fx_render_pass_add_rounded_rect(fx_pass, &rounded_rect_options);
 		} else {
 			fx_render_pass_add_rect(fx_pass, &rect_options);
 		}
 		break;
 	case WLR_SCENE_NODE_BUFFER:;
 		struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
 		struct fx_corner_radii buffer_corners = scene_buffer->corners;
 
 		if (scene_buffer->is_single_pixel_buffer) {
 			// TODO: Render blur/rounded corners/etc here:
 
 			// Render the buffer as a rect, this is likely to be more efficient
 			wlr_render_pass_add_rect(data->render_pass, &(struct wlr_render_rect_options){
 				.box = dst_box,
 				.color = {
 					.r = (float)scene_buffer->single_pixel_buffer_color[0] / (float)UINT32_MAX,
 					.g = (float)scene_buffer->single_pixel_buffer_color[1] / (float)UINT32_MAX,
 					.b = (float)scene_buffer->single_pixel_buffer_color[2] / (float)UINT32_MAX,
 					.a = (float)scene_buffer->single_pixel_buffer_color[3] /
 						(float)UINT32_MAX * scene_buffer->opacity,
 				},
 				.clip = &render_region,
 			});
 			break;
 		}
 
 		struct wlr_texture *texture = scene_buffer_get_texture(scene_buffer,
 			data->output->output->renderer);
 		if (texture == NULL) {
 			scene_output_damage(data->output, &render_region);
 			break;
 		}
 
 		enum wl_output_transform transform =
 			wlr_output_transform_invert(scene_buffer->transform);
 		transform = wlr_output_transform_compose(transform, data->transform);
 		fx_corner_radii_transform(transform, &buffer_corners);
 
 		struct wlr_color_primaries primaries = {0};
 		if (scene_buffer->primaries != 0) {
 			wlr_color_primaries_from_named(&primaries, scene_buffer->primaries);
 		}
 
 		struct wlr_color_luminances src_lum, srgb_lum;
 		wlr_color_transfer_function_get_default_luminance(
 			scene_buffer->transfer_function, &src_lum);
 		wlr_color_transfer_function_get_default_luminance(
 			WLR_COLOR_TRANSFER_FUNCTION_SRGB, &srgb_lum);
 		float luminance_multiplier = get_luminance_multiplier(&src_lum, &srgb_lum);
 
 		struct fx_render_texture_options tex_options = {
 			.base = (struct wlr_render_texture_options){
 				.texture = texture,
 				.src_box = scene_buffer->src_box,
 				.dst_box = dst_box,
 				.transform = transform,
 				.clip = &render_region, // Render with the smaller region, clipping CSD
 				.alpha = &scene_buffer->opacity,
 				.filter_mode = scene_buffer->filter_mode,
 				.blend_mode = !data->output->scene->calculate_visibility ||
 					!pixman_region32_empty(&opaque) ?
 					WLR_RENDER_BLEND_MODE_PREMULTIPLIED : WLR_RENDER_BLEND_MODE_NONE,
 				.transfer_function = scene_buffer->transfer_function,
 				.primaries = scene_buffer->primaries != 0 ? &primaries : NULL,
 				.color_encoding = scene_buffer->color_encoding,
 				.color_range = scene_buffer->color_range,
 				.luminance_multiplier = &luminance_multiplier,
 				.wait_timeline = scene_buffer->wait_timeline,
 				.wait_point = scene_buffer->wait_point,
 			},
 			.clip_box = &dst_box,
 			.corners = fx_corner_radii_scale(buffer_corners, data->scale),
 			.clipped_region = {0},
 		};
 
 		// TODO: Use the base wlr_render_pass_add_texture as a fast-path in the future
 		fx_render_pass_add_texture(fx_pass, &tex_options);
 
 		struct wlr_scene_output_sample_event sample_event = {
 			.output = data->output,
 			.direct_scanout = false,
 			.release_timeline = data->output->in_timeline,
 			.release_point = data->output->in_point,
 		};
 		wl_signal_emit_mutable(&scene_buffer->events.output_sample, &sample_event);
 
 		if (entry->highlight_transparent_region) {
 			wlr_render_pass_add_rect(data->render_pass, &(struct wlr_render_rect_options){
 					.box = dst_box,
 					.color = { .r = 0, .g = 0.3, .b = 0, .a = 0.3 },
 					.clip = &opaque,
 			});
 		}
 		break;
 	case WLR_SCENE_NODE_SHADOW:;
 		struct wlr_scene_shadow *scene_shadow = wlr_scene_shadow_from_node(node);
 
 		struct wlr_box shadow_clipped_region_box = scene_shadow->clipped_region.area;
 		struct fx_corner_radii shadow_clipped_corners = scene_shadow->clipped_region.corners;
 
 		// Node relative -> Root relative
 		shadow_clipped_region_box.x += x;
 		shadow_clipped_region_box.y += y;
 
 		transform_output_box(&shadow_clipped_region_box, data);
 		shadow_clipped_region_box.x += desk_dx;
 		shadow_clipped_region_box.y += desk_dy;
 		fx_corner_radii_transform(node_transform, &shadow_clipped_corners);
 
 		struct fx_render_box_shadow_options shadow_options = {
 			.box = dst_box,
 			.clipped_region = {
 				.area = shadow_clipped_region_box,
 				.corners = fx_corner_radii_scale(shadow_clipped_corners, data->scale),
 			},
 			.blur_sigma = scene_shadow->blur_sigma,
 			.corner_radius = scene_shadow->corner_radius * data->scale,
 			.color = {
 				.r = scene_shadow->color[0],
 				.g = scene_shadow->color[1],
 				.b = scene_shadow->color[2],
 				.a = scene_shadow->color[3],
 			},
 			.clip = &render_region,
 		};
 		fx_render_pass_add_box_shadow(fx_pass, &shadow_options);
 		break;
 	case WLR_SCENE_NODE_FRAME:;
 		struct wlr_scene_frame *scene_frame = wlr_scene_frame_from_node(node);
 
 		struct fx_render_frame_options frame_options = {
 			.box = dst_box,
 			/* Lengths are node-local logical px, like the bevel's
 			 * thickness and the exclusion rect below; the shader works
 			 * in buffer px, so every one takes the output scale. Left
 			 * unscaled, the handles drew at half size on a scale-2
 			 * output — and smaller than the compositor's hit zone,
 			 * which is sized in logical px. */
 			.corner_radius = scene_frame->corner_radius * data->scale,
 			.band = scene_frame->band * data->scale,
 			.band_min = scene_frame->band_min * data->scale,
 			.corner_len = scene_frame->corner_len * data->scale,
 			.gap = scene_frame->gap * data->scale,
 			.hovered = scene_frame->hovered,
 			.swell_curve = scene_frame->swell_curve,
 			.bulge = scene_frame->bulge * data->scale,
 			.buttons = scene_frame->buttons,
 			.exclusion = {
 				scene_frame->exclusion[0] * data->scale,
 				scene_frame->exclusion[1] * data->scale,
 				scene_frame->exclusion[2] * data->scale,
 				scene_frame->exclusion[3] * data->scale,
 			},
 			.hover_color = {
 				scene_frame->hover_color[0],
 				scene_frame->hover_color[1],
 				scene_frame->hover_color[2],
 				scene_frame->hover_color[3],
 			},
 			.color = {
 				.r = scene_frame->color[0],
 				.g = scene_frame->color[1],
 				.b = scene_frame->color[2],
 				.a = scene_frame->color[3],
 			},
 			.clip = &render_region,
 		};
 		fx_render_pass_add_frame(fx_pass, &frame_options);
 		break;
 	case WLR_SCENE_NODE_BEVEL:;
 		struct wlr_scene_bevel *scene_bevel = wlr_scene_bevel_from_node(node);
 
 		// The light direction is authored in screen space, so it has to
 		// follow the output transform along with the box it lights.
 		float bevel_dir_x = scene_bevel->light_dir[0];
 		float bevel_dir_y = scene_bevel->light_dir[1];
 		switch (node_transform) {
 		case WL_OUTPUT_TRANSFORM_90:
 			bevel_dir_x = scene_bevel->light_dir[1];
 			bevel_dir_y = -scene_bevel->light_dir[0];
 			break;
 		case WL_OUTPUT_TRANSFORM_180:
 			bevel_dir_x = -scene_bevel->light_dir[0];
 			bevel_dir_y = -scene_bevel->light_dir[1];
 			break;
 		case WL_OUTPUT_TRANSFORM_270:
 			bevel_dir_x = -scene_bevel->light_dir[1];
 			bevel_dir_y = scene_bevel->light_dir[0];
 			break;
 		default:
 			break;
 		}
 
 		struct fx_render_bevel_options bevel_options = {
 			.box = dst_box,
 			.corner_radius = scene_bevel->corner_radius * data->scale,
 			.thickness = scene_bevel->thickness * data->scale,
 			.light_dir = { bevel_dir_x, bevel_dir_y },
 			.light_intensity = scene_bevel->light_intensity,
 			.shade_intensity = scene_bevel->shade_intensity,
 			.shoulder = scene_bevel->shoulder,
 			.focus = scene_bevel->focus,
 			.focus_color = {
 				scene_bevel->focus_color[0],
 				scene_bevel->focus_color[1],
 				scene_bevel->focus_color[2],
 			},
 			.focus_sharpness = scene_bevel->focus_sharpness,
 			.color = {
 				.r = scene_bevel->color[0],
 				.g = scene_bevel->color[1],
 				.b = scene_bevel->color[2],
 				.a = scene_bevel->color[3],
 			},
 			.clip = &render_region,
 		};
 		fx_render_pass_add_bevel(fx_pass, &bevel_options);
 		break;
 	case WLR_SCENE_NODE_DROPLET:;
 		struct wlr_scene_droplet *scene_droplet = wlr_scene_droplet_from_node(node);
 
 		struct fx_render_droplet_options droplet_options = {
 			.box = dst_box,
 			.attach_r = scene_droplet->attach_r * data->scale,
 			.sheet_r = scene_droplet->sheet_r * data->scale,
 			.bow_rise = scene_droplet->bow_rise * data->scale,
 			.blend_k = scene_droplet->blend_k * data->scale,
 			.curve = scene_droplet->curve,
 			.band_px = scene_droplet->band_px * data->scale,
 			.refr = scene_droplet->refr * data->scale,
 			.ghost = scene_droplet->ghost,
 			.compress = {
 				.ceil = scene_droplet->compress_ceil,
 				.knee = scene_droplet->compress_knee,
 				.invert = scene_droplet->compress_invert,
 			},
 			.clip = &render_region,
 		};
 		fx_render_pass_add_droplet(fx_pass, &droplet_options);
 		break;
 	case WLR_SCENE_NODE_OPTIMIZED_BLUR:;
 		struct wlr_scene_optimized_blur *scene_blur = wlr_scene_optimized_blur_from_node(node);
 		// Bake (or top up) this node's cache entry. The dirty gate on a full
 		// bake is load-bearing: mark_dirty damages the node's whole box, so
 		// pass->buffer holds fresh below-node content when the bake samples
 		// it; strips are baked only where the node newly shows content, in
 		// the frame that composites it.
 		if (fx_pass->has_blur && is_scene_blur_enabled(&scene->blur_data)) {
 			optimized_blur_render(scene, scene_blur, node, fx_pass, data, dst_box);
 		}
 		break;
 	case WLR_SCENE_NODE_BLUR:;
 		struct wlr_scene_blur *blur = wlr_scene_blur_from_node(node);
 
 		struct wlr_texture *tex = NULL;
 		struct wlr_scene_buffer *mask = wlr_scene_blur_get_transparency_mask_source(blur);
 
 		enum wl_output_transform mask_transform = WL_OUTPUT_TRANSFORM_NORMAL;
 
 		struct wlr_fbox mask_src_box = {0};
 		if (mask != NULL) {
 			tex = scene_buffer_get_texture(mask, data->output->output->renderer);
 			mask_transform = wlr_output_transform_invert(mask->transform);
 			mask_transform = wlr_output_transform_compose(mask_transform, data->transform);
 			mask_src_box = mask->src_box;
 
 			// Map the blur box through the mask buffer's own geometry instead
 			// of stretching the whole mask texture over the blur rect: a mask
 			// buffer LARGER than the blur box (a client overflow rim — the
 			// surface extends transparently past the xdg geometry the blur is
 			// sized to) would otherwise squeeze its transparent rim INTO the
 			// box, and ignore_transparent then kills the blur in a rim-scaled
 			// band at the window's right/bottom. Sample exactly the sub-rect
 			// of the mask that overlaps the blur box, 1:1 in layout space.
 			// Congruent boxes (the common case) skip this and keep the
 			// previous full-texture mapping byte-for-byte.
 			if (tex != NULL) {
 				int mask_x, mask_y, blur_x, blur_y;
 				if (wlr_scene_node_coords(&mask->node, &mask_x, &mask_y) &&
 						wlr_scene_node_coords(node, &blur_x, &blur_y)) {
 					int mask_w = 0, mask_h = 0;
 					scene_node_get_size(&mask->node, &mask_w, &mask_h);
 					if (mask_w > 0 && mask_h > 0 &&
 							(mask_w != blur->width || mask_h != blur->height ||
 								mask_x != blur_x || mask_y != blur_y)) {
 						struct wlr_fbox full = mask_src_box;
 						if (full.width <= 0 || full.height <= 0) {
 							full = (struct wlr_fbox){
 								.x = 0,
 								.y = 0,
 								.width = tex->width,
 								.height = tex->height,
 							};
 						}
 						double sx = full.width / mask_w;
 						double sy = full.height / mask_h;
 						mask_src_box = (struct wlr_fbox){
 							.x = full.x + (blur_x - mask_x) * sx,
 							.y = full.y + (blur_y - mask_y) * sy,
 							.width = blur->width * sx,
 							.height = blur->height * sy,
 						};
 					}
 				}
 			}
 		}
 
 		struct fx_corner_radii blur_corners = blur->corners;
 		fx_corner_radii_transform(node_transform, &blur_corners);
 
 		// Sample the shared cache at this node's own bake: the sibling
 		// optimized node's anchor (its coordinates at its last full bake)
 		// plus the cache margin. The optimized node, rendered just before
 		// this one, has already baked whatever the node newly shows.
 		int cache_mx = 0, cache_my = 0;
 		if (fx_pass->fx_offscreen_buffers) {
 			cache_mx = fx_pass->fx_offscreen_buffers->cache_margin_x;
 			cache_my = fx_pass->fx_offscreen_buffers->cache_margin_y;
 		}
 		int shift_x = cache_mx, shift_y = cache_my;
 		if (blur->should_only_blur_bottom_layer &&
 				data->transform == WL_OUTPUT_TRANSFORM_NORMAL && node->parent) {
 			struct wlr_scene_node *sib;
 			wl_list_for_each(sib, &node->parent->children, link) {
 				if (sib->type != WLR_SCENE_NODE_OPTIMIZED_BLUR) {
 					continue;
 				}
 				struct wlr_scene_optimized_blur *opt = wlr_scene_optimized_blur_from_node(sib);
 				int cur_x, cur_y;
 				if (opt->baked && opt->baked_output == data->output &&
 						wlr_scene_node_coords(sib, &cur_x, &cur_y)) {
 					shift_x += (int)round((opt->baked_x - cur_x) * data->scale);
 					shift_y += (int)round((opt->baked_y - cur_y) * data->scale);
 				}
 				break;
 			}
 		}
 
 		struct fx_render_blur_pass_options blur_options = {
 			.tex_options = {
 				.base = (struct wlr_render_texture_options) {
 					.texture = tex,
 					.src_box = mask_src_box,
 					.dst_box = dst_box,
 					.transform = mask_transform,
 					.clip = &render_region,
 					.alpha = &blur->alpha,
 					.filter_mode = WLR_SCALE_FILTER_BILINEAR,
 					.blend_mode = WLR_RENDER_BLEND_MODE_PREMULTIPLIED,
 				},
 				.clip_box = &dst_box,
 				.corners = fx_corner_radii_scale(blur_corners, data->scale),
 				.discard_transparent = false,
 				.compress = {
 					.ceil = blur->compress_ceil,
 					.knee = blur->compress_knee,
 					.invert = blur->compress_invert,
 				},
 			},
 			.use_optimized_blur = blur->should_only_blur_bottom_layer,
 			.blur_data = &scene->blur_data,
 			.ignore_transparent = mask != NULL,
 			.blur_strength = blur->strength,
 			// Frozen cache: sample at this node's own delta since the freeze
 			// (layout px -> buffer px), so it reads its own bake. Only
 			// meaningful for an untransformed output; a rotated one gets
 			// the unshifted cache.
 			.cache_shift_x = shift_x,
 			.cache_shift_y = shift_y,
 		};
 		fx_render_pass_add_blur(fx_pass, &blur_options);
 		break;
 	}
 
 	pixman_region32_fini(&opaque);
 	pixman_region32_fini(&render_region);
 }
 
 static void scene_handle_linux_dmabuf_v1_destroy(struct wl_listener *listener,
 		void *data) {
 	struct wlr_scene *scene =
 		wl_container_of(listener, scene, linux_dmabuf_v1_destroy);
 	wl_list_remove(&scene->linux_dmabuf_v1_destroy.link);
 	wl_list_init(&scene->linux_dmabuf_v1_destroy.link);
 	scene->linux_dmabuf_v1 = NULL;
 }
 
 void wlr_scene_set_linux_dmabuf_v1(struct wlr_scene *scene,
 		struct wlr_linux_dmabuf_v1 *linux_dmabuf_v1) {
 	assert(scene->linux_dmabuf_v1 == NULL);
 	scene->linux_dmabuf_v1 = linux_dmabuf_v1;
 	scene->linux_dmabuf_v1_destroy.notify = scene_handle_linux_dmabuf_v1_destroy;
 	wl_signal_add(&linux_dmabuf_v1->events.destroy, &scene->linux_dmabuf_v1_destroy);
 }
 
 static void scene_handle_gamma_control_manager_v1_set_gamma(struct wl_listener *listener,
 		void *data) {
 	const struct wlr_gamma_control_manager_v1_set_gamma_event *event = data;
 	struct wlr_scene *scene =
 		wl_container_of(listener, scene, gamma_control_manager_v1_set_gamma);
 	struct wlr_scene_output *output = wlr_scene_get_scene_output(scene, event->output);
 	if (!output) {
 		// this scene might not own this output.
 		return;
 	}
 
 	output->gamma_lut_changed = true;
 	output->gamma_lut = event->control;
 	wlr_color_transform_unref(output->gamma_lut_color_transform);
 	output->gamma_lut_color_transform = wlr_gamma_control_v1_get_color_transform(event->control);
 	wlr_output_schedule_frame(output->output);
 }
 
 static void scene_handle_gamma_control_manager_v1_destroy(struct wl_listener *listener,
 		void *data) {
 	struct wlr_scene *scene =
 		wl_container_of(listener, scene, gamma_control_manager_v1_destroy);
 	wl_list_remove(&scene->gamma_control_manager_v1_destroy.link);
 	wl_list_init(&scene->gamma_control_manager_v1_destroy.link);
 	wl_list_remove(&scene->gamma_control_manager_v1_set_gamma.link);
 	wl_list_init(&scene->gamma_control_manager_v1_set_gamma.link);
 	scene->gamma_control_manager_v1 = NULL;
 
 	struct wlr_scene_output *output;
 	wl_list_for_each(output, &scene->outputs, link) {
 		output->gamma_lut_changed = false;
 		output->gamma_lut = NULL;
 		wlr_color_transform_unref(output->gamma_lut_color_transform);
 		output->gamma_lut_color_transform = NULL;
 	}
 }
 
 void wlr_scene_set_gamma_control_manager_v1(struct wlr_scene *scene,
 	    struct wlr_gamma_control_manager_v1 *gamma_control) {
 	assert(scene->gamma_control_manager_v1 == NULL);
 	scene->gamma_control_manager_v1 = gamma_control;
 
 	scene->gamma_control_manager_v1_destroy.notify =
 		scene_handle_gamma_control_manager_v1_destroy;
 	wl_signal_add(&gamma_control->events.destroy, &scene->gamma_control_manager_v1_destroy);
 	scene->gamma_control_manager_v1_set_gamma.notify =
 		scene_handle_gamma_control_manager_v1_set_gamma;
 	wl_signal_add(&gamma_control->events.set_gamma, &scene->gamma_control_manager_v1_set_gamma);
 }
 
 static void scene_handle_color_manager_v1_destroy(struct wl_listener *listener, void *data) {
 	struct wlr_scene *scene = wl_container_of(listener, scene, color_manager_v1_destroy);
 	wl_list_remove(&scene->color_manager_v1_destroy.link);
 	wl_list_init(&scene->color_manager_v1_destroy.link);
 	scene->color_manager_v1 = NULL;
 }
 
 void wlr_scene_set_color_manager_v1(struct wlr_scene *scene, struct wlr_color_manager_v1 *manager) {
 	assert(scene->color_manager_v1 == NULL);
 	scene->color_manager_v1 = manager;
 
 	scene->color_manager_v1_destroy.notify = scene_handle_color_manager_v1_destroy;
 	wl_signal_add(&manager->events.destroy, &scene->color_manager_v1_destroy);
 }
 
 static void scene_output_handle_destroy(struct wlr_addon *addon) {
 	struct wlr_scene_output *scene_output =
 		wl_container_of(addon, scene_output, addon);
 	wlr_scene_output_destroy(scene_output);
 }
 
 static const struct wlr_addon_interface output_addon_impl = {
 	.name = "wlr_scene_output",
 	.destroy = scene_output_handle_destroy,
 };
 
 static void scene_node_output_update(struct wlr_scene_node *node,
 		struct wl_list *outputs, struct wlr_scene_output *ignore,
 		struct wlr_scene_output *force) {
 	if (node->type == WLR_SCENE_NODE_TREE) {
 		struct wlr_scene_tree *scene_tree = wlr_scene_tree_from_node(node);
 		struct wlr_scene_node *child;
 		wl_list_for_each(child, &scene_tree->children, link) {
 			scene_node_output_update(child, outputs, ignore, force);
 		}
 		return;
 	}
 
 	update_node_update_outputs(node, outputs, ignore, force);
 }
 
 static void scene_output_update_geometry(struct wlr_scene_output *scene_output,
 		bool force_update) {
 	scene_output_damage_whole(scene_output);
 
 	scene_node_output_update(&scene_output->scene->tree.node,
 			&scene_output->scene->outputs, NULL, force_update ? scene_output : NULL);
 }
 
 static void scene_output_handle_commit(struct wl_listener *listener, void *data) {
 	struct wlr_scene_output *scene_output = wl_container_of(listener,
 		scene_output, output_commit);
 	struct wlr_output_event_commit *event = data;
 	const struct wlr_output_state *state = event->state;
 
 	// if the output has been committed with a certain damage, we know that region
 	// will be acknowledged by the backend so we don't need to keep track of it
 	// anymore
 	if (state->committed & WLR_OUTPUT_STATE_BUFFER) {
 		if (state->committed & WLR_OUTPUT_STATE_DAMAGE) {
 			pixman_region32_subtract(&scene_output->pending_commit_damage,
 				&scene_output->pending_commit_damage, &state->damage);
 		} else {
 			pixman_region32_fini(&scene_output->pending_commit_damage);
 			pixman_region32_init(&scene_output->pending_commit_damage);
 		}
 	}
 
 	bool force_update = state->committed & (
 		WLR_OUTPUT_STATE_TRANSFORM |
 		WLR_OUTPUT_STATE_SCALE |
 		WLR_OUTPUT_STATE_SUBPIXEL);
 
 	if (force_update || state->committed & (WLR_OUTPUT_STATE_MODE |
 			WLR_OUTPUT_STATE_ENABLED)) {
 		scene_output_update_geometry(scene_output, force_update);
 	}
 
 	if (scene_output->scene->debug_damage_option == WLR_SCENE_DEBUG_DAMAGE_HIGHLIGHT &&
 			!wl_list_empty(&scene_output->damage_highlight_regions)) {
 		wlr_output_schedule_frame(scene_output->output);
 	}
 
 	TRACY_WHEN_CONNECTED({
 		// Queue a new frame as soon as possible when profiling
 		wlr_output_schedule_frame(scene_output->output);
 	})
 
 	// Next time the output is enabled, try to re-apply the gamma LUT
 	if (scene_output->scene->gamma_control_manager_v1 &&
 			(state->committed & WLR_OUTPUT_STATE_ENABLED) &&
 			!scene_output->output->enabled) {
 		scene_output->gamma_lut_changed = true;
 	}
 }
 
 static void scene_output_handle_damage(struct wl_listener *listener, void *data) {
 	struct wlr_scene_output *scene_output = wl_container_of(listener,
 		scene_output, output_damage);
 	struct wlr_output *output = scene_output->output;
 	struct wlr_output_event_damage *event = data;
 
 	int width, height;
 	wlr_output_transformed_resolution(output, &width, &height);
 
 	pixman_region32_t damage;
 	pixman_region32_init(&damage);
 	pixman_region32_copy(&damage, event->damage);
 	wlr_region_transform(&damage, &damage,
 		wlr_output_transform_invert(output->transform), width, height);
 	scene_output_damage(scene_output, &damage);
 	pixman_region32_fini(&damage);
 }
 
 static void scene_output_handle_needs_frame(struct wl_listener *listener, void *data) {
 	struct wlr_scene_output *scene_output = wl_container_of(listener,
 		scene_output, output_needs_frame);
 	wlr_output_schedule_frame(scene_output->output);
 }
 
 struct wlr_scene_output *wlr_scene_output_create(struct wlr_scene *scene,
 		struct wlr_output *output) {
 	struct wlr_scene_output *scene_output = calloc(1, sizeof(*scene_output));
 	if (scene_output == NULL) {
 		return NULL;
 	}
 
 	scene_output->output = output;
 	scene_output->scene = scene;
 	wlr_addon_init(&scene_output->addon, &output->addons, scene, &output_addon_impl);
 
 	wlr_damage_ring_init(&scene_output->damage_ring);
 	pixman_region32_init(&scene_output->pending_commit_damage);
 	wl_list_init(&scene_output->damage_highlight_regions);
 
 	int prev_output_index = -1;
 	struct wl_list *prev_output_link = &scene->outputs;
 
 	struct wlr_scene_output *current_output;
 	wl_list_for_each(current_output, &scene->outputs, link) {
 		if (prev_output_index + 1 != current_output->index) {
 			break;
 		}
 
 		prev_output_index = current_output->index;
 		prev_output_link = &current_output->link;
 	}
 
 	int drm_fd = wlr_backend_get_drm_fd(output->backend);
 	if (drm_fd >= 0 && output->backend->features.timeline &&
 			output->renderer != NULL && output->renderer->features.timeline) {
 		scene_output->in_timeline = wlr_drm_syncobj_timeline_create(drm_fd);
 		scene_output->out_timeline = wlr_drm_syncobj_timeline_create(drm_fd);
 		if (scene_output->in_timeline == NULL || scene_output->out_timeline == NULL) {
 			wlr_drm_syncobj_timeline_unref(scene_output->in_timeline);
 			wlr_drm_syncobj_timeline_unref(scene_output->out_timeline);
 			return NULL;
 		}
 	}
 
 	scene_output->index = prev_output_index + 1;
 	assert(scene_output->index < 64);
 	wl_list_insert(prev_output_link, &scene_output->link);
 
 	wl_signal_init(&scene_output->events.destroy);
 
 	scene_output->output_commit.notify = scene_output_handle_commit;
 	wl_signal_add(&output->events.commit, &scene_output->output_commit);
 
 	scene_output->output_damage.notify = scene_output_handle_damage;
 	wl_signal_add(&output->events.damage, &scene_output->output_damage);
 
 	scene_output->output_needs_frame.notify = scene_output_handle_needs_frame;
 	wl_signal_add(&output->events.needs_frame, &scene_output->output_needs_frame);
 
 	scene_output_update_geometry(scene_output, false);
 
 	return scene_output;
 }
 
 static void highlight_region_destroy(struct highlight_region *damage) {
 	wl_list_remove(&damage->link);
 	pixman_region32_fini(&damage->region);
 	free(damage);
 }
 
 void wlr_scene_output_destroy(struct wlr_scene_output *scene_output) {
 	if (scene_output == NULL) {
 		return;
 	}
 
 	wl_signal_emit_mutable(&scene_output->events.destroy, NULL);
 
 	scene_node_output_update(&scene_output->scene->tree.node,
 		&scene_output->scene->outputs, scene_output, NULL);
 
 	assert(wl_list_empty(&scene_output->events.destroy.listener_list));
 
 	struct highlight_region *damage, *tmp_damage;
 	wl_list_for_each_safe(damage, tmp_damage, &scene_output->damage_highlight_regions, link) {
 		highlight_region_destroy(damage);
 	}
 
 	wlr_addon_finish(&scene_output->addon);
 	wlr_damage_ring_finish(&scene_output->damage_ring);
 	pixman_region32_fini(&scene_output->pending_commit_damage);
 	wl_list_remove(&scene_output->link);
 	wl_list_remove(&scene_output->output_commit.link);
 	wl_list_remove(&scene_output->output_damage.link);
 	wl_list_remove(&scene_output->output_needs_frame.link);
 	if (scene_output->in_timeline != NULL) {
 		wlr_drm_syncobj_timeline_signal(scene_output->in_timeline, UINT64_MAX);
 		wlr_drm_syncobj_timeline_unref(scene_output->in_timeline);
 	}
 	if (scene_output->out_timeline != NULL) {
 		wlr_drm_syncobj_timeline_signal(scene_output->out_timeline, UINT64_MAX);
 		wlr_drm_syncobj_timeline_unref(scene_output->out_timeline);
 	}
 	wlr_color_transform_unref(scene_output->gamma_lut_color_transform);
 	wlr_color_transform_unref(scene_output->prev_gamma_lut_color_transform);
 	wlr_color_transform_unref(scene_output->prev_supplied_color_transform);
 	wlr_color_transform_unref(scene_output->combined_color_transform);
 	wl_array_release(&scene_output->render_list);
 	free(scene_output);
 }
 
 struct wlr_scene_output *wlr_scene_get_scene_output(struct wlr_scene *scene,
 		struct wlr_output *output) {
 	struct wlr_addon *addon =
 		wlr_addon_find(&output->addons, scene, &output_addon_impl);
 	if (addon == NULL) {
 		return NULL;
 	}
 	struct wlr_scene_output *scene_output =
 		wl_container_of(addon, scene_output, addon);
 	return scene_output;
 }
 
 void wlr_scene_output_set_position(struct wlr_scene_output *scene_output,
 		int lx, int ly) {
 	if (scene_output->x == lx && scene_output->y == ly) {
 		return;
 	}
 
 	scene_output->x = lx;
 	scene_output->y = ly;
 
 	scene_output_update_geometry(scene_output, false);
 }
 
 static bool scene_node_invisible(struct wlr_scene_node *node) {
 	if (node->type == WLR_SCENE_NODE_TREE) {
 		return true;
 	} else if (node->type == WLR_SCENE_NODE_RECT) {
 		struct wlr_scene_rect *rect = wlr_scene_rect_from_node(node);
 		// TODO: Check if clipped region covers whole rect?
 		return rect->color[3] == 0.f;
 	} else if (node->type == WLR_SCENE_NODE_BUFFER) {
 		struct wlr_scene_buffer *buffer = wlr_scene_buffer_from_node(node);
 
 		return buffer->buffer == NULL && buffer->texture == NULL;
 	} else if (node->type == WLR_SCENE_NODE_SHADOW) {
 		struct wlr_scene_shadow *shadow = wlr_scene_shadow_from_node(node);
 
 		return shadow->color[3] == 0.f;
 	} else if (node->type == WLR_SCENE_NODE_BEVEL) {
 		struct wlr_scene_bevel *bevel = wlr_scene_bevel_from_node(node);
 
 		return bevel->color[3] == 0.f || bevel->thickness <= 0.f;
 	} else if (node->type == WLR_SCENE_NODE_FRAME) {
 		struct wlr_scene_frame *frame = wlr_scene_frame_from_node(node);
 
 		return frame->color[3] == 0.f || frame->band <= 0.f;
 	}
 
 	return false;
 }
 
 struct render_list_constructor_data {
 	struct wlr_box box;
 	struct wl_array *render_list;
 	bool calculate_visibility;
 	bool highlight_transparent_region;
 	bool fractional_scale;
 };
 
 static bool scene_buffer_is_black_opaque(struct wlr_scene_buffer *scene_buffer) {
 	return scene_buffer->is_single_pixel_buffer &&
 		scene_buffer->single_pixel_buffer_color[0] == 0 &&
 		scene_buffer->single_pixel_buffer_color[1] == 0 &&
 		scene_buffer->single_pixel_buffer_color[2] == 0 &&
 		scene_buffer->single_pixel_buffer_color[3] == UINT32_MAX &&
 		scene_buffer->opacity == 1.0 &&
 		fx_corner_radii_is_empty(&scene_buffer->corners);
 }
 
 static bool scene_rect_is_black_opaque(struct wlr_scene_rect *scene_rect) {
 	return scene_rect->color[0] == 0.f &&
 		scene_rect->color[1] == 0.f &&
 		scene_rect->color[2] == 0.f &&
 		scene_rect->color[3] == 1.f &&
 		scene_rect->fade_inset == 0 &&
 		fx_corner_radii_is_empty(&scene_rect->corners) &&
 		fx_corner_radii_is_empty(&scene_rect->clipped_region.corners) &&
 		wlr_box_empty(&scene_rect->clipped_region.area);
 }
 
 static bool construct_render_list_iterator(struct wlr_scene_node *node,
 		int lx, int ly, void *_data) {
 	struct render_list_constructor_data *data = _data;
 
 	if (scene_node_invisible(node)) {
 		return false;
 	}
 
 	// While rendering, the background should always be black. If we see a
 	// black rect, we can ignore rendering everything under the rect, and
 	// unless fractional scale is used even the rect itself (to avoid running
 	// into issues regarding damage region expansion).
 	if (node->type == WLR_SCENE_NODE_RECT && data->calculate_visibility &&
 			(!data->fractional_scale || data->render_list->size == 0)) {
 		struct wlr_scene_rect *rect = wlr_scene_rect_from_node(node);
 
 		if (scene_rect_is_black_opaque(rect)) {
 			return false;
 		}
 	}
 
 	// Apply the same special-case to black opaque single-pixel buffers
 	if (node->type == WLR_SCENE_NODE_BUFFER && data->calculate_visibility &&
 			(!data->fractional_scale || data->render_list->size == 0)) {
 		struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
 
 		if (scene_buffer_is_black_opaque(scene_buffer)) {
 			return false;
 		}
 	}
 
 	pixman_region32_t intersection;
 	pixman_region32_init(&intersection);
 	pixman_region32_intersect_rect(&intersection, &node->visible,
 			data->box.x, data->box.y,
 			data->box.width, data->box.height);
 	if (pixman_region32_empty(&intersection)) {
 		pixman_region32_fini(&intersection);
 		return false;
 	}
 
 	pixman_region32_fini(&intersection);
 
 	struct render_list_entry *entry = wl_array_add(data->render_list, sizeof(*entry));
 	if (!entry) {
 		return false;
 	}
 
 	*entry = (struct render_list_entry){
 		.node = node,
 		.x = lx,
 		.y = ly,
 		.highlight_transparent_region = data->highlight_transparent_region,
 	};
 
 	return false;
 }
 
 static void scene_buffer_send_dmabuf_feedback(const struct wlr_scene *scene,
 		struct wlr_scene_buffer *scene_buffer,
 		const struct wlr_linux_dmabuf_feedback_v1_init_options *options) {
 	if (!scene->linux_dmabuf_v1) {
 		return;
 	}
 
 	struct wlr_scene_surface *surface = wlr_scene_surface_try_from_buffer(scene_buffer);
 	if (!surface) {
 		return;
 	}
 
 	// compare to the previous options so that we don't send
 	// duplicate feedback events.
 	if (memcmp(options, &scene_buffer->prev_feedback_options, sizeof(*options)) == 0) {
 		return;
 	}
 
 	scene_buffer->prev_feedback_options = *options;
 
 	// One line per feedback that actually goes out (the memcmp above having
 	// found a real change). Each carries an fd to the client, so a burst here
 	// is the fd-exhaustion signature: `grep -c 'dmabuf feedback sent'`.
 	wlr_log(WLR_DEBUG, "dmabuf feedback sent (scanout_output=%p)",
 		(void *)options->scanout_primary_output);
 
 	struct wlr_linux_dmabuf_feedback_v1 feedback = {0};
 	if (!wlr_linux_dmabuf_feedback_v1_init_with_options(&feedback, options)) {
 		return;
 	}
 
 	enum wl_output_transform preferred_buffer_transform = WL_OUTPUT_TRANSFORM_NORMAL;
 	if (options->scanout_primary_output != NULL) {
 		preferred_buffer_transform = options->scanout_primary_output->transform;
 	}
 
 	// TODO: also send wl_surface.preferred_buffer_transform when running with
 	// pure software rendering
 	wlr_surface_set_preferred_buffer_transform(surface->surface, preferred_buffer_transform);
 	wlr_linux_dmabuf_v1_set_surface_feedback(scene->linux_dmabuf_v1,
 		surface->surface, &feedback);
 
 	wlr_linux_dmabuf_feedback_v1_finish(&feedback);
 }
 
 static bool color_management_is_scanout_allowed(const struct wlr_output_image_description *img_desc,
 		const struct wlr_scene_buffer *buffer) {
 	// Disallow scanout if the output has colorimetry information but buffer
 	// doesn't; allow it only if the output also lacks it.
 	if (buffer->transfer_function == 0 && buffer->primaries == 0) {
 		return img_desc == NULL;
 	}
 
 	// If the output has colorimetry information, the buffer must match it for
 	// direct scanout to be allowed.
 	if (img_desc != NULL) {
 		return img_desc->transfer_function == buffer->transfer_function &&
 				img_desc->primaries == buffer->primaries;
 	}
 	// If the output doesn't have colorimetry image description set, we can only
 	// scan out buffers with default colorimetry (gamma2.2 transfer and sRGB
 	// primaries) used in wlroots.
 	return buffer->transfer_function == WLR_COLOR_TRANSFER_FUNCTION_GAMMA22 &&
 			buffer->primaries == WLR_COLOR_NAMED_PRIMARIES_SRGB;
 }
 
 enum scene_direct_scanout_result {
 	// This scene node is not a candidate for scanout
 	SCANOUT_INELIGIBLE,
 
 	// This scene node is a candidate for scanout, but is currently
 	// incompatible due to e.g. buffer mismatch, and if possible we'd like to
 	// resolve this incompatibility.
 	SCANOUT_CANDIDATE,
 
 	// Scanout is successful.
 	SCANOUT_SUCCESS,
 };
 
 static enum scene_direct_scanout_result scene_entry_try_direct_scanout(
 		struct render_list_entry *entry, struct wlr_output_state *state,
 		const struct render_data *data) {
 	struct wlr_scene_output *scene_output = data->output;
 	struct wlr_scene_node *node = entry->node;
 
 	if (!scene_output->scene->direct_scanout) {
 		return SCANOUT_INELIGIBLE;
 	}
 
 	if (node->type != WLR_SCENE_NODE_BUFFER) {
 		return SCANOUT_INELIGIBLE;
 	}
 
 	// A desk node drawn with a sub-pixel shift is not where its buffer
 	// would be scanned out.
 	{
 		int dx, dy;
 		scene_desk_offset_px(scene_output->scene, data->scale, data->transform, &dx, &dy);
 		if ((dx != 0 || dy != 0) && scene_node_has_desk_offset(scene_output->scene, node)) {
 			return SCANOUT_INELIGIBLE;
 		}
 	}
 
 	if (state->committed & (WLR_OUTPUT_STATE_MODE |
 			WLR_OUTPUT_STATE_ENABLED |
 			WLR_OUTPUT_STATE_RENDER_FORMAT)) {
 		// Legacy DRM will explode if we try to modeset with a direct scanout buffer
 		return SCANOUT_INELIGIBLE;
 	}
 
 	if (!wlr_output_is_direct_scanout_allowed(scene_output->output)) {
 		return SCANOUT_INELIGIBLE;
 	}
 
 	struct wlr_scene_buffer *buffer = wlr_scene_buffer_from_node(node);
 	if (buffer->buffer == NULL) {
 		return SCANOUT_INELIGIBLE;
 	}
 
 	// The native size of the buffer after any transform is applied
 	int default_width = buffer->buffer->width;
 	int default_height = buffer->buffer->height;
 	wlr_output_transform_coords(buffer->transform, &default_width, &default_height);
 	struct wlr_fbox default_box = {
 		.width = default_width,
 		.height = default_height,
 	};
 
 	if (buffer->transform != data->transform) {
 		return SCANOUT_INELIGIBLE;
 	}
 
 	const struct wlr_output_image_description *img_desc = output_pending_image_description(scene_output->output, state);
 	if (!color_management_is_scanout_allowed(img_desc, buffer)) {
 		return SCANOUT_INELIGIBLE;
 	}
 
 	bool is_color_repr_none = buffer->color_encoding == WLR_COLOR_ENCODING_NONE &&
 			buffer->color_range == WLR_COLOR_RANGE_NONE;
 	bool is_color_repr_identity_full = buffer->color_encoding == WLR_COLOR_ENCODING_IDENTITY &&
 			buffer->color_range == WLR_COLOR_RANGE_FULL;
 
 	if (!(is_color_repr_none || is_color_repr_identity_full)) {
 		return SCANOUT_INELIGIBLE;
 	}
 
 	// We want to ensure optimal buffer selection, but as direct-scanout can be enabled and disabled
 	// on a frame-by-frame basis, we wait for a few frames to send the new format recommendations.
 	// Maybe we should only send feedback in this case if tests fail.
 	if (scene_output->dmabuf_feedback_debounce >= DMABUF_FEEDBACK_DEBOUNCE_FRAMES
 			&& buffer->primary_output == scene_output) {
 		struct wlr_linux_dmabuf_feedback_v1_init_options options = {
 			.main_renderer = scene_output->output->renderer,
 			.scanout_primary_output = scene_output->output,
 		};
 
 		scene_buffer_send_dmabuf_feedback(scene_output->scene, buffer, &options);
 	}
 
 	struct wlr_output_state pending;
 	wlr_output_state_init(&pending);
 	if (!wlr_output_state_copy(&pending, state)) {
 		return SCANOUT_CANDIDATE;
 	}
 
 	if (!wlr_fbox_empty(&buffer->src_box) &&
 			!wlr_fbox_equal(&buffer->src_box, &default_box)) {
 		pending.buffer_src_box = buffer->src_box;
 	}
 
 	// Translate the position from scene coordinates to output coordinates
 	pending.buffer_dst_box.x = entry->x - scene_output->x;
 	pending.buffer_dst_box.y = entry->y - scene_output->y;
 
 	scene_node_get_size(node, &pending.buffer_dst_box.width, &pending.buffer_dst_box.height);
 	transform_output_box(&pending.buffer_dst_box, data);
 
 	struct wlr_buffer *wlr_buffer = buffer->buffer;
 	struct wlr_client_buffer *client_buffer = wlr_client_buffer_get(wlr_buffer);
 	if (client_buffer != NULL && client_buffer->source != NULL && client_buffer->source->n_locks > 0) {
 		wlr_buffer = client_buffer->source;
 	}
 
 	wlr_output_state_set_buffer(&pending, wlr_buffer);
 	if (buffer->wait_timeline != NULL) {
 		wlr_output_state_set_wait_timeline(&pending, buffer->wait_timeline, buffer->wait_point);
 	}
 
 	if (scene_output->out_timeline) {
 		scene_output->out_point++;
 		wlr_output_state_set_signal_timeline(&pending, scene_output->out_timeline, scene_output->out_point);
 	}
 
 	if (!wlr_output_test_state(scene_output->output, &pending)) {
 		wlr_output_state_finish(&pending);
 		return SCANOUT_CANDIDATE;
 	}
 
 	wlr_output_state_copy(state, &pending);
 	wlr_output_state_finish(&pending);
 
 	struct wlr_scene_output_sample_event sample_event = {
 		.output = scene_output,
 		.direct_scanout = true,
 		.release_timeline = data->output->out_timeline,
 		.release_point = data->output->out_point,
 	};
 	wl_signal_emit_mutable(&buffer->events.output_sample, &sample_event);
 	return SCANOUT_SUCCESS;
 }
 
 bool wlr_scene_output_needs_frame(struct wlr_scene_output *scene_output) {
 	return scene_output->output->needs_frame ||
 		!pixman_region32_empty(&scene_output->pending_commit_damage) ||
 		scene_output->gamma_lut_changed;
 }
 
 static bool should_blur_node_extend_damage(struct wlr_scene_node *node,
 		struct fx_gles_render_pass *fx_pass, struct blur_data *blur_data) {
 	switch (node->type) {
 	case WLR_SCENE_NODE_BLUR:;
 		struct wlr_scene_blur *blur_node = wlr_scene_blur_from_node(node);
 		// No artifact prevention needed when the whole blur is already
 		// rendered
 		if (blur_node->should_only_blur_bottom_layer && blur_node->strength == 1.0) {
 			fx_pass->has_blur = true;
 			return false;
 		}
 		// Apply the blur strength to avoid rendering more blur than
 		// what's needed
 		if (blur_node->strength < 1.0f) {
 			*blur_data = blur_data_apply_strength(blur_data, blur_node->strength);
 		}
 		break;
 	case WLR_SCENE_NODE_OPTIMIZED_BLUR:;
 		struct wlr_scene_optimized_blur *optimized_node =
 			wlr_scene_optimized_blur_from_node(node);
 		if (!optimized_node->dirty) {
 			return false;
 		}
 		break;
 	case WLR_SCENE_NODE_DROPLET:;
 		// The droplet lens samples the frame-so-far around itself, so it has
 		// the same stale-sample problem the blur comment below describes:
 		// partial damage under or NEAR the drop leaves neighboring pixels
 		// holding last frame's final composite (including the drop's own
 		// output), and re-rendering only the damaged sliver bakes those into
 		// part of the lens while the rest keeps the old frame — which is
 		// exactly the visible/invisible flashing on segments whose text
 		// ticks (clock, battery). Whole-node re-render, independent of the
 		// scene blur config.
 		struct wlr_scene_droplet *droplet_node = wlr_scene_droplet_from_node(node);
 		if (droplet_node->refr <= 0.0f && droplet_node->ghost <= 0.0f) {
 			return false;
 		}
 		return true;
 	default:
 		return false;
 	}
 
 	return is_scene_blur_enabled(blur_data);
 }
 
 static bool apply_blur_region(struct wlr_scene_node *node, struct blur_data *blur_data,
 		struct render_data *render_data, struct wlr_output_state *output_state,
 		const pixman_region32_t *original_damage, pixman_region32_t *blur_padding_region) {
 	bool should_compensate_blur = false;
 	int sample_size = blur_data_calc_size(blur_data);
 	if (node->type == WLR_SCENE_NODE_DROPLET) {
 		// The droplet's sampling reach: rim refraction plus the inverted
 		// ghost's span (0.35 x the box about its center) — the same margin
 		// fx_render_pass_add_droplet copies. Node fields are logical px.
 		struct wlr_scene_droplet *droplet = wlr_scene_droplet_from_node(node);
 		int dim = droplet->width > droplet->height ? droplet->width : droplet->height;
 		sample_size = (int)((droplet->refr + 1.0f + 0.35f * (float)dim)
 				* render_data->scale) + 1;
 	}
 
 	pixman_region32_t node_visible_region;
 	pixman_region32_init(&node_visible_region);
 	pixman_region32_copy(&node_visible_region, &node->visible);
 	pixman_region32_translate(&node_visible_region, -render_data->output->x, -render_data->output->y);
 	logical_to_buffer_coords(&node_visible_region, render_data, false);
 
 	pixman_region32_t expanded_damage;
 	pixman_region32_init(&expanded_damage);
 	wlr_region_expand(&expanded_damage, original_damage, sample_size);
 
 	pixman_region32_t intersection;
 	pixman_region32_init(&intersection);
 	pixman_region32_intersect(&intersection, &expanded_damage, &node_visible_region);
 	// pixman_region32_intersect's return value reports allocation success,
 	// not a non-empty result — testing it here made EVERY blur node count as
 	// touched by EVERY frame's damage, so all of them re-blurred (and pulled
 	// their whole box into the damage) whenever anything on screen changed:
 	// one animating window cost a full re-blur of every status segment and
 	// translucent window each frame. Only a node the expanded damage
 	// actually reaches has stale samples to worry about.
 	if (pixman_region32_not_empty(&intersection)) {
 		should_compensate_blur = true;
 		if (cce_scene_blur_debug()) {
 			const pixman_box32_t *nv = pixman_region32_extents(&node_visible_region);
 			const pixman_box32_t *od = pixman_region32_extents(original_damage);
 			wlr_log(WLR_INFO, "[scenefx] blur_region: type=%d sample=%d node=(%d,%d)-(%d,%d) orig=(%d,%d)-(%d,%d)",
 				node->type, sample_size, nv->x1, nv->y1, nv->x2, nv->y2,
 				od->x1, od->y1, od->x2, od->y2);
 		}
 
 		// Re-render the node's entire blur region, not just the damaged
 		// sliver: the blur samples the framebuffer up to sample_size beyond
 		// the damage, where pixels still hold the previous frame's final
 		// composited content — including this node's own content drawn above
 		// the blur. Re-blurring only the sliver bakes those stale samples
 		// into part of the backdrop while neighboring pixels keep last
 		// frame's blur, which shimmers whenever damage sweeps underneath
 		// (e.g. grid lines during a desktop pan). Re-blurring the whole node
 		// computes every pixel from the same freshly rendered below-content.
 		pixman_region32_union(&render_data->damage, &render_data->damage, &node_visible_region);
 		// Also make sure that the backend also knows about the new
 		// damage. Very important
 		output_state->committed |= WLR_OUTPUT_STATE_DAMAGE;
 		pixman_region32_union(&output_state->damage, &output_state->damage, &node_visible_region);
 
 		// Expand it once more to get the blur padding region
 		// which is key for artifact removal :)
 		wlr_region_expand(&intersection, &node_visible_region, sample_size);
 		// Don't re-add already added rectangles
 		pixman_region32_subtract(&intersection, &intersection, blur_padding_region);
 		pixman_region32_union(blur_padding_region, blur_padding_region, &intersection);
 	}
 
 	pixman_region32_fini(&intersection);
 	pixman_region32_fini(&expanded_damage);
 	pixman_region32_fini(&node_visible_region);
 	return should_compensate_blur;
 }
 
 bool wlr_scene_output_commit(struct wlr_scene_output *scene_output,
 		const struct wlr_scene_output_state_options *options) {
 	if (!wlr_scene_output_needs_frame(scene_output)) {
 		return true;
 	}
 
 	bool ok = false;
 	struct wlr_output_state state;
 	wlr_output_state_init(&state);
 	if (!wlr_scene_output_build_state(scene_output, &state, options)) {
 		goto out;
 	}
 
 	ok = wlr_output_commit_state(scene_output->output, &state);
 	if (!ok) {
 		goto out;
 	}
 
 out:
 	wlr_output_state_finish(&state);
 	return ok;
 }
 
 static void scene_output_state_attempt_gamma(struct wlr_scene_output *scene_output,
 		struct wlr_output_state *state) {
 	if (!scene_output->gamma_lut_changed) {
 		return;
 	}
 
 	struct wlr_output_state gamma_pending = {0};
 	if (!wlr_output_state_copy(&gamma_pending, state)) {
 		return;
 	}
 
 	wlr_output_state_set_color_transform(&gamma_pending, scene_output->gamma_lut_color_transform);
 	scene_output->gamma_lut_changed = false;
 
 	if (!wlr_output_test_state(scene_output->output, &gamma_pending)) {
 		wlr_gamma_control_v1_send_failed_and_destroy(scene_output->gamma_lut);
 
 		scene_output->gamma_lut = NULL;
 		wlr_color_transform_unref(scene_output->gamma_lut_color_transform);
 		scene_output->gamma_lut_color_transform = NULL;
 		wlr_output_state_finish(&gamma_pending);
 		return;
 	}
 
 	wlr_output_state_copy(state, &gamma_pending);
 	wlr_output_state_finish(&gamma_pending);
 }
 
 static bool scene_output_combine_color_transforms(
 		struct wlr_scene_output *scene_output, struct wlr_color_transform *supplied,
 		const struct wlr_output_image_description *img_desc, bool render_gamma_lut) {
 	bool result = false;
 	struct wlr_color_transform *color_matrix = NULL;
 	struct wlr_color_transform *inv_eotf = NULL;
 	struct wlr_color_transform *user_gamma = NULL;
 
 	if (img_desc != NULL) {
 		assert(supplied == NULL);
 		struct wlr_color_primaries primaries_srgb;
 		wlr_color_primaries_from_named(&primaries_srgb, WLR_COLOR_NAMED_PRIMARIES_SRGB);
 		struct wlr_color_primaries primaries;
 		wlr_color_primaries_from_named(&primaries, img_desc->primaries);
 		float matrix[9];
 		wlr_color_primaries_transform_absolute_colorimetric(&primaries_srgb, &primaries, matrix);
 
 		struct wlr_color_luminances srgb_lum, dst_lum;
 		wlr_color_transfer_function_get_default_luminance(
 			WLR_COLOR_TRANSFER_FUNCTION_SRGB, &srgb_lum);
 		wlr_color_transfer_function_get_default_luminance(img_desc->transfer_function, &dst_lum);
 		float luminance_multiplier = get_luminance_multiplier(&srgb_lum, &dst_lum);
 		for (int i = 0; i < 9; ++i) {
 			matrix[i] *= luminance_multiplier;
 		}
 
 		color_matrix = wlr_color_transform_init_matrix(matrix);
 		inv_eotf = wlr_color_transform_init_linear_to_inverse_eotf(img_desc->transfer_function);
 		if (color_matrix == NULL || inv_eotf == NULL) {
 			goto cleanup_transforms;
 		}
 	} else if (supplied != NULL) {
 		inv_eotf = wlr_color_transform_ref(supplied);
 	} else {
 		inv_eotf = wlr_color_transform_init_linear_to_inverse_eotf(
 			WLR_COLOR_TRANSFER_FUNCTION_GAMMA22);
 		if (inv_eotf == NULL) {
 			goto cleanup_transforms;
 		}
 	}
 
 	struct wlr_color_transform *gamma_lut = scene_output->gamma_lut_color_transform;
 	if (gamma_lut != NULL && render_gamma_lut) {
 		user_gamma = wlr_color_transform_ref(gamma_lut);
 	}
 
 	struct wlr_color_transform *combined;
 	struct wlr_color_transform *transforms[] = {
 		color_matrix,
 		inv_eotf,
 		user_gamma,
 	};
 	const size_t transforms_len = sizeof(transforms) / sizeof(transforms[0]);
 	if (!color_transform_compose(&combined, transforms, transforms_len)) {
 		goto cleanup_transforms;
 	}
 
 	wlr_color_transform_unref(scene_output->prev_gamma_lut_color_transform);
 	scene_output->prev_gamma_lut_color_transform = gamma_lut ? wlr_color_transform_ref(gamma_lut) : NULL;
 	wlr_color_transform_unref(scene_output->prev_supplied_color_transform);
 	scene_output->prev_supplied_color_transform = supplied ? wlr_color_transform_ref(supplied) : NULL;
 	wlr_color_transform_unref(scene_output->combined_color_transform);
 	scene_output->combined_color_transform = combined;
 
 	result = true;
 
 cleanup_transforms:
 	wlr_color_transform_unref(color_matrix);
 	wlr_color_transform_unref(inv_eotf);
 	wlr_color_transform_unref(user_gamma);
 	return result;
 }
 
 bool wlr_scene_output_build_state(struct wlr_scene_output *scene_output,
 		struct wlr_output_state *state, const struct wlr_scene_output_state_options *options) {
 	struct wlr_scene_output_state_options default_options = {0};
 	if (!options) {
 		options = &default_options;
 	}
 	struct wlr_scene_timer *timer = options->timer;
 	struct timespec start_time;
 	if (timer) {
 		clock_gettime(CLOCK_MONOTONIC, &start_time);
 		wlr_scene_timer_finish(timer);
 		*timer = (struct wlr_scene_timer){0};
 	}
 
 	if ((state->committed & WLR_OUTPUT_STATE_ENABLED) && !state->enabled) {
 		// if the state is being disabled, do nothing.
 		return true;
 	}
 
 	struct wlr_output *output = scene_output->output;
 	enum wlr_scene_debug_damage_option debug_damage =
 		scene_output->scene->debug_damage_option;
 
 	bool render_gamma_lut = false;
 	if (wlr_output_get_gamma_size(output) == 0 && output->renderer->features.output_color_transform) {
 		if (scene_output->gamma_lut_color_transform != scene_output->prev_gamma_lut_color_transform) {
 			scene_output_damage_whole(scene_output);
 		}
 		if (scene_output->gamma_lut_color_transform != NULL) {
 			render_gamma_lut = true;
 		}
 	}
 
 	struct render_data render_data = {
 		.transform = output->transform,
 		.scale = output->scale,
 		.logical = { .x = scene_output->x, .y = scene_output->y },
 		.output = scene_output,
 	};
 
 	int resolution_width, resolution_height;
 	output_pending_resolution(output, state,
 		&resolution_width, &resolution_height);
 
 	if (state->committed & WLR_OUTPUT_STATE_TRANSFORM) {
 		if (render_data.transform != state->transform) {
 			scene_output_damage_whole(scene_output);
 		}
 
 		render_data.transform = state->transform;
 	}
 
 	if (state->committed & WLR_OUTPUT_STATE_SCALE) {
 		if (render_data.scale != state->scale) {
 			scene_output_damage_whole(scene_output);
 		}
 
 		render_data.scale = state->scale;
 	}
 
 	render_data.trans_width = resolution_width;
 	render_data.trans_height = resolution_height;
 	wlr_output_transform_coords(render_data.transform,
 		&render_data.trans_width, &render_data.trans_height);
 
 	render_data.logical.width = render_data.trans_width / render_data.scale;
 	render_data.logical.height = render_data.trans_height / render_data.scale;
 
 	struct render_list_constructor_data list_con = {
 		.box = render_data.logical,
 		.render_list = &scene_output->render_list,
 		.calculate_visibility = scene_output->scene->calculate_visibility,
 		.highlight_transparent_region = scene_output->scene->highlight_transparent_region,
 		.fractional_scale = floor(render_data.scale) != render_data.scale,
 	};
 
 	list_con.render_list->size = 0;
 	scene_nodes_in_box(&scene_output->scene->tree.node, &list_con.box,
 		construct_render_list_iterator, &list_con);
 	array_realloc(list_con.render_list, list_con.render_list->size);
 
 	struct render_list_entry *list_data = list_con.render_list->data;
 	int list_len = list_con.render_list->size / sizeof(*list_data);
 
 	if (debug_damage == WLR_SCENE_DEBUG_DAMAGE_RERENDER) {
 		scene_output_damage_whole(scene_output);
 	}
 
 	struct timespec now;
 	if (debug_damage == WLR_SCENE_DEBUG_DAMAGE_HIGHLIGHT) {
 		struct wl_list *regions = &scene_output->damage_highlight_regions;
 		clock_gettime(CLOCK_MONOTONIC, &now);
 
 		// add the current frame's damage if there is damage
 		if (!pixman_region32_empty(&scene_output->damage_ring.current)) {
 			struct highlight_region *current_damage = calloc(1, sizeof(*current_damage));
 			if (current_damage) {
 				pixman_region32_init(&current_damage->region);
 				pixman_region32_copy(&current_damage->region,
 					&scene_output->damage_ring.current);
 				current_damage->when = now;
 				wl_list_insert(regions, &current_damage->link);
 			}
 		}
 
 		pixman_region32_t acc_damage;
 		pixman_region32_init(&acc_damage);
 		struct highlight_region *damage, *tmp_damage;
 		wl_list_for_each_safe(damage, tmp_damage, regions, link) {
 			// remove overlapping damage regions
 			pixman_region32_subtract(&damage->region, &damage->region, &acc_damage);
 			pixman_region32_union(&acc_damage, &acc_damage, &damage->region);
 
 			// if this damage is too old or has nothing in it, get rid of it
 			struct timespec time_diff;
 			timespec_sub(&time_diff, &now, &damage->when);
 			if (timespec_to_msec(&time_diff) >= HIGHLIGHT_DAMAGE_FADEOUT_TIME ||
 					pixman_region32_empty(&damage->region)) {
 				highlight_region_destroy(damage);
 			}
 		}
 
 		scene_output_damage(scene_output, &acc_damage);
 		pixman_region32_fini(&acc_damage);
 	}
 
 	wlr_output_state_set_damage(state, &scene_output->pending_commit_damage);
 
 	// We only want to try direct scanout if:
 	// - There is only one entry in the render list
 	// - There are no color transforms that need to be applied
 	// - Damage highlight debugging is not enabled
 	enum scene_direct_scanout_result scanout_result = SCANOUT_INELIGIBLE;
 	if (options->color_transform == NULL && !render_gamma_lut && list_len == 1
 			&& debug_damage != WLR_SCENE_DEBUG_DAMAGE_HIGHLIGHT) {
 		scanout_result = scene_entry_try_direct_scanout(&list_data[0], state, &render_data);
 	}
 
 	if (scanout_result == SCANOUT_INELIGIBLE) {
 		if (scene_output->dmabuf_feedback_debounce > 0) {
 			// We cannot scan out, so count down towards sending composition dmabuf feedback
 			scene_output->dmabuf_feedback_debounce--;
 		}
 	} else if (scene_output->dmabuf_feedback_debounce < DMABUF_FEEDBACK_DEBOUNCE_FRAMES) {
 		// We either want to scan out or successfully scanned out, so count up towards sending
 		// scanout dmabuf feedback
 		scene_output->dmabuf_feedback_debounce++;
 	}
 
 	bool scanout = scanout_result == SCANOUT_SUCCESS;
 	if (scene_output->prev_scanout != scanout) {
 		scene_output->prev_scanout = scanout;
 		wlr_log(WLR_DEBUG, "Direct scan-out %s",
 			scanout ? "enabled" : "disabled");
 	}
 
 	if (scanout) {
 		scene_output_state_attempt_gamma(scene_output, state);
 
 		if (timer) {
 			struct timespec end_time, duration;
 			clock_gettime(CLOCK_MONOTONIC, &end_time);
 			timespec_sub(&duration, &end_time, &start_time);
 			timer->pre_render_duration = timespec_to_nsec(&duration);
 		}
 
 		TRACY_MARK_FRAME;
 		return true;
 	}
 
 	struct wlr_swapchain *swapchain = options->swapchain;
 	if (!swapchain) {
 		if (!wlr_output_configure_primary_swapchain(output, state, &output->swapchain)) {
 			TRACY_MARK_FRAME;
 			return false;
 		}
 
 		swapchain = output->swapchain;
 	}
 
 	struct wlr_buffer *buffer = wlr_swapchain_acquire(swapchain);
 	if (buffer == NULL) {
 		TRACY_MARK_FRAME;
 		return false;
 	}
 
 	assert(buffer->width == resolution_width && buffer->height == resolution_height);
 
 	if (timer) {
 		timer->render_timer = wlr_render_timer_create(output->renderer);
 
 		struct timespec end_time, duration;
 		clock_gettime(CLOCK_MONOTONIC, &end_time);
 		timespec_sub(&duration, &end_time, &start_time);
 		timer->pre_render_duration = timespec_to_nsec(&duration);
 	}
 
 	if ((render_gamma_lut
 			&& scene_output->gamma_lut_color_transform != scene_output->prev_gamma_lut_color_transform)
 			|| scene_output->prev_supplied_color_transform != options->color_transform
 			|| (state->committed & WLR_OUTPUT_STATE_IMAGE_DESCRIPTION)) {
 		const struct wlr_output_image_description *output_description =
 			output_pending_image_description(output, state);
 		if (!scene_output_combine_color_transforms(scene_output, options->color_transform,
 				output_description, render_gamma_lut)) {
 			wlr_buffer_unlock(buffer);
 			return false;
 		}
 	}
 
 	scene_output->in_point++;
 	struct wlr_render_pass *render_pass = wlr_renderer_begin_buffer_pass(output->renderer, buffer,
 			&(struct wlr_buffer_pass_options){
 		.timer = timer ? timer->render_timer : NULL,
 		.color_transform = scene_output->combined_color_transform,
 		.signal_timeline = scene_output->in_timeline,
 		.signal_point = scene_output->in_point,
 	});
 	if (render_pass == NULL) {
 		wlr_buffer_unlock(buffer);
 
 		TRACY_MARK_FRAME;
 		return false;
 	}
 
 	render_data.render_pass = render_pass;
 
 	pixman_region32_init(&render_data.damage);
 	wlr_damage_ring_rotate_buffer(&scene_output->damage_ring, buffer,
 		&render_data.damage);
 
 	struct fx_gles_render_pass *fx_pass = fx_get_render_pass(render_pass);
 	bool should_compensate_blur = false;
 	if (fx_render_pass_init_offscreen_buffers(render_pass, output)
 			&& pixman_region32_not_empty(&render_data.damage)) {
 		// Software cursors are baked into the reused buffer, so their recent
 		// footprints must be treated as damage before the blur compensation
 		// geometry is computed: inside the damage they get re-blurred with
 		// full sampling context, and the padding restore (which excludes
 		// damage) can never paste a stale cursor back. The live cursor is
 		// redrawn on top afterwards since
 		// wlr_output_add_software_cursors_to_render_pass() clips to this
 		// damage.
 		if (is_scene_blur_enabled(&scene_output->scene->blur_data)) {
 			struct wlr_output_cursor *cursor;
 			wl_list_for_each(cursor, &output->cursors, link) {
 				if (!cursor->enabled || !cursor->visible) {
 					continue;
 				}
 				double scale = output->scale;
 				g_cursor_history[g_cursor_history_index].x =
 					(cursor->x - cursor->hotspot_x) * scale;
 				g_cursor_history[g_cursor_history_index].y =
 					(cursor->y - cursor->hotspot_y) * scale;
 				g_cursor_history[g_cursor_history_index].w = cursor->width;
 				g_cursor_history[g_cursor_history_index].h = cursor->height;
 				g_cursor_history[g_cursor_history_index].valid = true;
 				g_cursor_history[g_cursor_history_index].output = output;
 				g_cursor_history_index =
 					(g_cursor_history_index + 1) % CURSOR_HISTORY_SIZE;
 			}
 
 			// Newest first, this output's only, the most recent few.
 			for (int k = 1, taken = 0; k <= CURSOR_HISTORY_SIZE && taken < CURSOR_HISTORY_DAMAGE; k++) {
 				int i = (g_cursor_history_index - k + CURSOR_HISTORY_SIZE) % CURSOR_HISTORY_SIZE;
 				if (!g_cursor_history[i].valid || g_cursor_history[i].output != output) {
 					continue;
 				}
 				taken++;
 				pixman_region32_union_rect(&render_data.damage, &render_data.damage,
 						g_cursor_history[i].x - 16,
 						g_cursor_history[i].y - 16,
 						g_cursor_history[i].w + 32,
 						g_cursor_history[i].h + 32);
 				pixman_region32_union_rect(&state->damage, &state->damage,
 						g_cursor_history[i].x - 16,
 						g_cursor_history[i].y - 16,
 						g_cursor_history[i].w + 32,
 						g_cursor_history[i].h + 32);
 				state->committed |= WLR_OUTPUT_STATE_DAMAGE;
 			}
 			pixman_region32_intersect_rect(&render_data.damage, &render_data.damage,
 					0, 0, output->width, output->height);
 		}
 
 		// Blur artifact prevention
 		// Note: Supports individual blur node blur_data
 		pixman_region32_t original_damage;
 		pixman_region32_init(&original_damage);
 		pixman_region32_copy(&original_damage, &render_data.damage);
 
 		// Only compensate for blur artifacts when the damage doesn't cover
 		// the whole output. Test actual coverage, not extents: scattered
 		// damage (e.g. every grid cell rect moving during a desktop pan)
 		// has full-output extents while being mostly holes, and skipping
 		// compensation then leaves each blur node re-blurring only slivers
 		// against stale framebuffer content.
 		pixman_box32_t full_output_box = {
 			.x1 = 0, .y1 = 0,
 			.x2 = output->width, .y2 = output->height,
 		};
 		const bool full_damage = pixman_region32_contains_rectangle(
 			&original_damage, &full_output_box) == PIXMAN_REGION_IN;
 
 		// The extra region we copy and paste onto the framebuffer after render
 		// for artifact removal
 		pixman_region32_t blur_padding_region;
 		pixman_region32_init(&blur_padding_region);
 
 		// Check if the original damage expanded by the to-be-rendered blur
 		// nodes sampling size intersects with said nodes visible region. The
 		// intersection gets expanded once more which becomes the region to be
 		// copied before render and pasted onto the framebuffer after render
 		// (the region where artifacts will be visible). This method fixes blur
 		// nodes not updating properly when nearby, non-blurred nodes get
 		// damaged while avoiding to re-render the whole nodes blur region. It
 		// also allows for node-individual blur_data if needed in the future.
 		for (int i = list_len - 1; i >= 0; i--) {
 			struct render_list_entry *entry = &list_data[i];
 			struct wlr_scene_node *node = entry->node;
 			struct blur_data blur_data = scene_output->scene->blur_data;
 			if (!should_blur_node_extend_damage(node, fx_pass, &blur_data)) {
 				continue;
 			}
 
 			// End early. No need to compensate for blur if the whole output
 			// is damaged anyway, but still make sure to let the renderer know that
 			// there's blur nodes to render.
 			if (full_damage) {
 				should_compensate_blur = false;
 				fx_pass->has_blur = true;
 				break;
 			}
 
 			if (apply_blur_region(node, &blur_data, &render_data, state,
 						&original_damage, &blur_padding_region)) {
 				should_compensate_blur = true;
 				fx_pass->has_blur = true;
 			}
 		}
 
 		// Expand the damage to compensate for blur
 		if (should_compensate_blur) {
 			// Capture the padding pixels around the blur where artifacts will be drawn
 			pixman_region32_subtract(&fx_pass->blur_padding_region,
 					&blur_padding_region, &render_data.damage);
 			// Make sure that the padding and damage doesn't exceed the output bounds
 			pixman_region32_intersect_rect(&fx_pass->blur_padding_region, &fx_pass->blur_padding_region,
 					0, 0, output->width, output->height);
 
 			// Combine with the render damage (we need to redraw the padding area as well)
 			pixman_region32_union(&render_data.damage,
 					&render_data.damage, &fx_pass->blur_padding_region);
 			pixman_region32_intersect_rect(&render_data.damage, &render_data.damage,
 					0, 0, output->width, output->height);
 
 			// Copy the surrounding content where the blur would display artifacts
 			// and draw it above the artifacts. Otherwise The old rendered
 			// content would be included into the new blur. This means that
 			// content like a high z-index toplevel would be included into the
 			// blur of a toplevel with a low z-index.
 			fx_render_pass_read_to_buffer(fx_pass, &fx_pass->blur_padding_region,
 					fx_pass->fx_offscreen_buffers->blur_saved_pixels_buffer, fx_pass->buffer);
 		}
 
 		pixman_region32_fini(&blur_padding_region);
 		pixman_region32_fini(&original_damage);
 	}
 
 	pixman_region32_t background;
 	pixman_region32_init(&background);
 	pixman_region32_copy(&background, &render_data.damage);
 
 	// Cull areas of the background that are occluded by opaque regions of
 	// scene nodes above. Those scene nodes will just render atop having us
 	// never see the background.
 	if (scene_output->scene->calculate_visibility) {
 		for (int i = list_len - 1; i >= 0; i--) {
 			struct render_list_entry *entry = &list_data[i];
 
 			// We must only cull opaque regions that are visible by the node.
 			// The node's visibility will have the knowledge of a black rect
 			// that may have been omitted from the render list via the black
 			// rect optimization. In order to ensure we don't cull background
 			// rendering in that black rect region, consider the node's visibility.
 			pixman_region32_t opaque;
 			pixman_region32_init(&opaque);
 			scene_node_opaque_region(entry->node, entry->x, entry->y, &opaque);
 			pixman_region32_intersect(&opaque, &opaque, &entry->node->visible);
 
 			pixman_region32_translate(&opaque, -scene_output->x, -scene_output->y);
 			logical_to_buffer_coords(&opaque, &render_data, false);
 			pixman_region32_subtract(&background, &background, &opaque);
 			pixman_region32_fini(&opaque);
 		}
 
 		if (floor(render_data.scale) != render_data.scale) {
 			wlr_region_expand(&background, &background, 1);
 
 			// reintersect with the damage because we never want to render
 			// outside of the damage region
 			pixman_region32_intersect(&background, &background, &render_data.damage);
 		}
 	}
 
 	wlr_render_pass_add_rect(render_pass, &(struct wlr_render_rect_options){
 		.box = { .width = buffer->width, .height = buffer->height },
 		.color = { .r = 0, .g = 0, .b = 0, .a = 1 },
 		.clip = &background,
 	});
 	pixman_region32_fini(&background);
 
 	for (int i = list_len - 1; i >= 0; i--) {
 		struct render_list_entry *entry = &list_data[i];
 		scene_entry_render(entry, &render_data);
 
 		if (entry->node->type == WLR_SCENE_NODE_BUFFER) {
 			struct wlr_scene_buffer *buffer = wlr_scene_buffer_from_node(entry->node);
 
 			// Direct scanout counts up to DMABUF_FEEDBACK_DEBOUNCE_FRAMES before sending new dmabuf
 			// feedback, and on composition we wait until it hits zero again. If we knew that an
 			// entry could never be a scanout candidate, we could send feedback to it
 			// unconditionally without debounce, but for now it is all or nothing
 			if (scene_output->dmabuf_feedback_debounce == 0 && buffer->primary_output == scene_output) {
 				struct wlr_linux_dmabuf_feedback_v1_init_options options = {
 					.main_renderer = output->renderer,
 					.scanout_primary_output = NULL,
 				};
 
 				scene_buffer_send_dmabuf_feedback(scene_output->scene, buffer, &options);
 			}
 		}
 	}
 
 	if (debug_damage == WLR_SCENE_DEBUG_DAMAGE_HIGHLIGHT) {
 		struct highlight_region *damage;
 		wl_list_for_each(damage, &scene_output->damage_highlight_regions, link) {
 			struct timespec time_diff;
 			timespec_sub(&time_diff, &now, &damage->when);
 			int64_t time_diff_ms = timespec_to_msec(&time_diff);
 			float alpha = 1.0 - (double)time_diff_ms / HIGHLIGHT_DAMAGE_FADEOUT_TIME;
 
 			wlr_render_pass_add_rect(render_pass, &(struct wlr_render_rect_options){
 				.box = { .width = buffer->width, .height = buffer->height },
 				.color = { .r = alpha * 0.5, .g = 0, .b = 0, .a = alpha * 0.5 },
 				.clip = &damage->region,
 			});
 		}
 	}
 
 	if (should_compensate_blur) {
 		// Render the saved pixels over the blur artifacts
 		fx_render_pass_read_to_buffer(fx_pass, &fx_pass->blur_padding_region,
 				fx_pass->buffer, fx_pass->fx_offscreen_buffers->blur_saved_pixels_buffer);
 	}
 
 	wlr_output_add_software_cursors_to_render_pass(output, render_pass, &render_data.damage);
 
 	pixman_region32_fini(&render_data.damage);
 
 	if (!wlr_render_pass_submit(render_pass)) {
 		wlr_buffer_unlock(buffer);
 
 		// if we failed to render the buffer, it will have undefined contents
 		// Trash the damage ring
 		wlr_damage_ring_add_whole(&scene_output->damage_ring);
 
 		TRACY_MARK_FRAME;
 		return false;
 	}
 
 	wlr_output_state_set_buffer(state, buffer);
 	wlr_buffer_unlock(buffer);
 
 	if (scene_output->in_timeline != NULL) {
 		wlr_output_state_set_wait_timeline(state, scene_output->in_timeline,
 			scene_output->in_point);
 		scene_output->out_point++;
 		wlr_output_state_set_signal_timeline(state, scene_output->out_timeline,
 			scene_output->out_point);
 	}
 
 	if (!render_gamma_lut) {
 		scene_output_state_attempt_gamma(scene_output, state);
 	}
 
 	TRACY_MARK_FRAME;
 	return true;
 }
 
 int64_t wlr_scene_timer_get_duration_ns(struct wlr_scene_timer *timer) {
 	int64_t pre_render = timer->pre_render_duration;
 	if (!timer->render_timer) {
 		return pre_render;
 	}
 	int64_t render = wlr_render_timer_get_duration_ns(timer->render_timer);
 	return render != -1 ? pre_render + render : -1;
 }
 
 void wlr_scene_timer_finish(struct wlr_scene_timer *timer) {
 	if (timer->render_timer) {
 		wlr_render_timer_destroy(timer->render_timer);
 	}
 }
 
 static void scene_node_send_frame_done(struct wlr_scene_node *node,
 		struct wlr_scene_output *scene_output, struct timespec *now) {
 	if (!node->enabled) {
 		return;
 	}
 
 	if (node->type == WLR_SCENE_NODE_BUFFER) {
 		struct wlr_scene_buffer *scene_buffer =
 			wlr_scene_buffer_from_node(node);
 		struct wlr_scene_frame_done_event event = {
 			.output = scene_output,
 			.when = *now,
 		};
 		wlr_scene_buffer_send_frame_done(scene_buffer, &event);
 	} else if (node->type == WLR_SCENE_NODE_TREE) {
 		struct wlr_scene_tree *scene_tree = wlr_scene_tree_from_node(node);
 		struct wlr_scene_node *child;
 		wl_list_for_each(child, &scene_tree->children, link) {
 			scene_node_send_frame_done(child, scene_output, now);
 		}
 	}
 }
 
 void wlr_scene_output_send_frame_done(struct wlr_scene_output *scene_output,
 		struct timespec *now) {
 	scene_node_send_frame_done(&scene_output->scene->tree.node,
 		scene_output, now);
 }
 
 static void scene_output_for_each_scene_buffer(const struct wlr_box *output_box,
 		struct wlr_scene_node *node, int lx, int ly,
 		wlr_scene_buffer_iterator_func_t user_iterator, void *user_data) {
 	if (!node->enabled) {
 		return;
 	}
 
 	lx += node->x;
 	ly += node->y;
 
 	if (node->type == WLR_SCENE_NODE_BUFFER) {
 		struct wlr_box node_box = { .x = lx, .y = ly };
 		scene_node_get_size(node, &node_box.width, &node_box.height);
 
 		struct wlr_box intersection;
 		if (wlr_box_intersection(&intersection, output_box, &node_box)) {
 			struct wlr_scene_buffer *scene_buffer =
 				wlr_scene_buffer_from_node(node);
 			user_iterator(scene_buffer, lx, ly, user_data);
 		}
 	} else if (node->type == WLR_SCENE_NODE_TREE) {
 		struct wlr_scene_tree *scene_tree = wlr_scene_tree_from_node(node);
 		struct wlr_scene_node *child;
 		wl_list_for_each(child, &scene_tree->children, link) {
 			scene_output_for_each_scene_buffer(output_box, child, lx, ly,
 				user_iterator, user_data);
 		}
 	}
 }
 
 void wlr_scene_output_for_each_buffer(struct wlr_scene_output *scene_output,
 		wlr_scene_buffer_iterator_func_t iterator, void *user_data) {
 	struct wlr_box box = { .x = scene_output->x, .y = scene_output->y };
 	wlr_output_effective_resolution(scene_output->output,
 		&box.width, &box.height);
 	scene_output_for_each_scene_buffer(&box, &scene_output->scene->tree.node, 0, 0,
 		iterator, user_data);
 }