Merge branch 'master' into texture-redesign

backend/x11/backend.c

@@ -326,9 +326,6 @@ static void wlr_x11_backend_destroy(struct wlr_backend *backend) {
 	wl_event_source_remove(x11->frame_timer);
 	wlr_egl_finish(&x11->egl);
 
-	if (x11->xcb_conn) {
-		xcb_disconnect(x11->xcb_conn);
-	}
 	if (x11->xlib_conn) {
 		XCloseDisplay(x11->xlib_conn);
 	}
@@ -428,7 +425,6 @@ struct wlr_backend *wlr_x11_backend_create(struct wl_display *display,
 error_event:
 	wl_event_source_remove(x11->event_source);
 error_x11:
-	xcb_disconnect(x11->xcb_conn);
 	XCloseDisplay(x11->xlib_conn);
 	free(x11);
 	return NULL;

examples/tablet.c

@@ -49,7 +49,6 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
 	wlr_renderer_begin(sample->renderer, wlr_output->width, wlr_output->height);
 	wlr_renderer_clear(sample->renderer, (float[]){0.25f, 0.25f, 0.25f, 1});
 
-	float matrix[9];
 	float distance = 0.8f * (1 - sample->distance);
 	float tool_color[4] = { distance, distance, distance, 1 };
 	for (size_t i = 0; sample->button && i < 4; ++i) {
@@ -61,12 +60,12 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
 	float pad_height = sample->height_mm * scale;
 	float left = width / 2.0f - pad_width / 2.0f;
 	float top = height / 2.0f - pad_height / 2.0f;
-	struct wlr_box box = {
+	const struct wlr_box box = {
 		.x = left, .y = top,
 		.width = pad_width, .height = pad_height,
 	};
-	wlr_matrix_project_box(matrix, &box, 0, 0, wlr_output->transform_matrix);
+	wlr_render_rect(sample->renderer, &box, sample->pad_color,
-	wlr_render_colored_quad(sample->renderer, sample->pad_color, matrix);
+		wlr_output->transform_matrix);
 
 	if (sample->proximity) {
 		struct wlr_box box = {
@@ -75,16 +74,17 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts
 			.width = 16 * (sample->pressure + 1),
 			.height = 16 * (sample->pressure + 1),
 		};
-		wlr_matrix_project_box(matrix, &box, 0, sample->ring,
+		float matrix[9];
-			wlr_output->transform_matrix);
+		wlr_matrix_project_box(matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL,
-		wlr_render_colored_quad(sample->renderer, tool_color, matrix);
+			sample->ring, wlr_output->transform_matrix);
+		wlr_render_quad_with_matrix(sample->renderer, tool_color, matrix);
+
 		box.x += sample->x_tilt;
 		box.y += sample->y_tilt;
 		box.width /= 2;
 		box.height /= 2;
-		wlr_matrix_project_box(matrix, &box, 0, 0,
+		wlr_render_rect(sample->renderer, &box, tool_color,
 			wlr_output->transform_matrix);
-		wlr_render_colored_quad(sample->renderer, tool_color, matrix);
 	}
 
 	wlr_renderer_end(sample->renderer);

include/rootston/config.h

@@ -66,8 +66,10 @@ struct roots_config {
 	struct wl_list bindings;
 	struct wl_list keyboards;
 	struct wl_list cursors;
+
 	char *config_path;
 	char *startup_cmd;
+	bool debug_damage_tracking;
 };
 
 /**

include/wlr/render/interface.h

@@ -26,9 +26,9 @@ struct wlr_renderer_impl {
 	bool (*render_texture_with_matrix)(struct wlr_renderer *renderer,
 		struct wlr_texture *texture, const float matrix[static 9],
 		float alpha);
-	void (*render_quad)(struct wlr_renderer *renderer,
+	void (*render_quad_with_matrix)(struct wlr_renderer *renderer,
 		const float color[static 4], const float matrix[static 9]);
-	void (*render_ellipse)(struct wlr_renderer *renderer,
+	void (*render_ellipse_with_matrix)(struct wlr_renderer *renderer,
 		const float color[static 4], const float matrix[static 9]);
 	const enum wl_shm_format *(*formats)(
 		struct wlr_renderer *renderer, size_t *len);

include/wlr/render/wlr_renderer.h

@@ -30,14 +30,24 @@ bool wlr_render_texture(struct wlr_renderer *r, struct wlr_texture *texture,
 bool wlr_render_texture_with_matrix(struct wlr_renderer *r,
 	struct wlr_texture *texture, const float matrix[static 9], float alpha);
 /**
- * Renders a solid quad in the specified color.
+ * Renders a solid rectangle in the specified color.
  */
-void wlr_render_colored_quad(struct wlr_renderer *r,
+void wlr_render_rect(struct wlr_renderer *r, const struct wlr_box *box,
+	const float color[static 4], const float projection[static 9]);
+/**
+ * Renders a solid quadrangle in the specified color with the specified matrix.
+ */
+void wlr_render_quad_with_matrix(struct wlr_renderer *r,
 	const float color[static 4], const float matrix[static 9]);
 /**
  * Renders a solid ellipse in the specified color.
  */
-void wlr_render_colored_ellipse(struct wlr_renderer *r,
+void wlr_render_ellipse(struct wlr_renderer *r, const struct wlr_box *box,
+	const float color[static 4], const float projection[static 9]);
+/**
+ * Renders a solid ellipse in the specified color with the specified matrix.
+ */
+void wlr_render_ellipse_with_matrix(struct wlr_renderer *r,
 	const float color[static 4], const float matrix[static 9]);
 /**
  * Returns a list of pixel formats supported by this renderer.

include/wlr/types/wlr_box.h

@@ -27,7 +27,7 @@ void wlr_box_transform(const struct wlr_box *box,
 	struct wlr_box *dest);
 
 /**
- * Creates the smallest box that contains a rotated box.
+ * Creates the smallest box that contains the box rotated about its center.
  */
 void wlr_box_rotated_bounds(const struct wlr_box *box, float rotation,
 	struct wlr_box *dest);

include/wlr/util/region.h

@@ -26,4 +26,11 @@ void wlr_region_transform(pixman_region32_t *dst, pixman_region32_t *src,
 void wlr_region_expand(pixman_region32_t *dst, pixman_region32_t *src,
 	int distance);
 
+/*
+ * Builds the smallest possible region that contains the region rotated about
+ * the point (ox, oy).
+ */
+void wlr_region_rotated_bounds(pixman_region32_t *dst, pixman_region32_t *src,
+	float rotation, int ox, int oy);
+
 #endif

render/gles2/renderer.c

@@ -155,7 +155,7 @@ static bool gles2_render_texture_with_matrix(struct wlr_renderer *wlr_renderer,
 }
 
 
-static void gles2_render_quad(struct wlr_renderer *wlr_renderer,
+static void gles2_render_quad_with_matrix(struct wlr_renderer *wlr_renderer,
 		const float color[static 4], const float matrix[static 9]) {
 	struct wlr_gles2_renderer *renderer =
 		gles2_get_renderer_in_context(wlr_renderer);
@@ -173,7 +173,7 @@ static void gles2_render_quad(struct wlr_renderer *wlr_renderer,
 	GLES2_DEBUG_POP;
 }
 
-static void gles2_render_ellipse(struct wlr_renderer *wlr_renderer,
+static void gles2_render_ellipse_with_matrix(struct wlr_renderer *wlr_renderer,
 		const float color[static 4], const float matrix[static 9]) {
 	struct wlr_gles2_renderer *renderer =
 		gles2_get_renderer_in_context(wlr_renderer);
@@ -286,8 +286,8 @@ static const struct wlr_renderer_impl renderer_impl = {
 	.clear = gles2_clear,
 	.scissor = gles2_scissor,
 	.render_texture_with_matrix = gles2_render_texture_with_matrix,
-	.render_quad = gles2_render_quad,
+	.render_quad_with_matrix = gles2_render_quad_with_matrix,
-	.render_ellipse = gles2_render_ellipse,
+	.render_ellipse_with_matrix = gles2_render_ellipse_with_matrix,
 	.formats = gles2_renderer_formats,
 	.resource_is_wl_drm_buffer = gles2_resource_is_wl_drm_buffer,
 	.wl_drm_buffer_get_size = gles2_wl_drm_buffer_get_size,

render/wlr_renderer.c

@@ -11,8 +11,8 @@ void wlr_renderer_init(struct wlr_renderer *renderer,
 	assert(impl->clear);
 	assert(impl->scissor);
 	assert(impl->render_texture_with_matrix);
-	assert(impl->render_quad);
+	assert(impl->render_quad_with_matrix);
-	assert(impl->render_ellipse);
+	assert(impl->render_ellipse_with_matrix);
 	assert(impl->formats);
 	assert(impl->format_supported);
 	assert(impl->texture_from_pixels);
@@ -47,16 +47,14 @@ void wlr_renderer_scissor(struct wlr_renderer *r, struct wlr_box *box) {
 
 bool wlr_render_texture(struct wlr_renderer *r, struct wlr_texture *texture,
 		const float projection[static 9], int x, int y, float alpha) {
-	int width, height;
+	struct wlr_box box = { .x = x, .y = y };
-	wlr_texture_get_size(texture, &width, &height);
+	wlr_texture_get_size(texture, &box.width, &box.height);
 
-	float mat[9];
+	float matrix[9];
-	wlr_matrix_identity(mat);
+	wlr_matrix_project_box(matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL, 0,
-	wlr_matrix_translate(mat, x, y);
+		projection);
-	wlr_matrix_scale(mat, width, height);
-	wlr_matrix_multiply(mat, projection, mat);
 
-	return wlr_render_texture_with_matrix(r, texture, mat, alpha);
+	return wlr_render_texture_with_matrix(r, texture, matrix, alpha);
 }
 
 bool wlr_render_texture_with_matrix(struct wlr_renderer *r,
@@ -65,14 +63,32 @@ bool wlr_render_texture_with_matrix(struct wlr_renderer *r,
 	return r->impl->render_texture_with_matrix(r, texture, matrix, alpha);
 }
 
-void wlr_render_colored_quad(struct wlr_renderer *r,
+void wlr_render_rect(struct wlr_renderer *r, const struct wlr_box *box,
+		const float color[static 4], const float projection[static 9]) {
+	float matrix[9];
+	wlr_matrix_project_box(matrix, box, WL_OUTPUT_TRANSFORM_NORMAL, 0,
+		projection);
+
+	wlr_render_quad_with_matrix(r, color, matrix);
+}
+
+void wlr_render_quad_with_matrix(struct wlr_renderer *r,
 		const float color[static 4], const float matrix[static 9]) {
-	r->impl->render_quad(r, color, matrix);
+	r->impl->render_quad_with_matrix(r, color, matrix);
+}
+
+void wlr_render_ellipse(struct wlr_renderer *r, const struct wlr_box *box,
+		const float color[static 4], const float projection[static 9]) {
+	float matrix[9];
+	wlr_matrix_project_box(matrix, box, WL_OUTPUT_TRANSFORM_NORMAL, 0,
+		projection);
+
+	wlr_render_ellipse_with_matrix(r, color, matrix);
 }
 
-void wlr_render_colored_ellipse(struct wlr_renderer *r,
+void wlr_render_ellipse_with_matrix(struct wlr_renderer *r,
 		const float color[static 4], const float matrix[static 9]) {
-	r->impl->render_ellipse(r, color, matrix);
+	r->impl->render_ellipse_with_matrix(r, color, matrix);
 }
 
 const enum wl_shm_format *wlr_renderer_get_formats(

rootston/config.c

@@ -25,7 +25,9 @@ static void usage(const char *name, int ret) {
 		"                (default: rootston.ini).\n"
 		"                See `rootston.ini.example` for config\n"
 		"                file documentation.\n"
-		" -E <COMMAND>   Command that will be ran at startup.\n" , name);
+		" -E <COMMAND>   Command that will be ran at startup.\n"
+		" -D             Enable damage tracking debugging.\n",
+		name);
 
 	exit(ret);
 }
@@ -394,7 +396,7 @@ struct roots_config *roots_config_create_from_args(int argc, char *argv[]) {
 	wl_list_init(&config->bindings);
 
 	int c;
-	while ((c = getopt(argc, argv, "C:E:h")) != -1) {
+	while ((c = getopt(argc, argv, "C:E:hD")) != -1) {
 		switch (c) {
 		case 'C':
 			config->config_path = strdup(optarg);
@@ -402,6 +404,9 @@ struct roots_config *roots_config_create_from_args(int argc, char *argv[]) {
 		case 'E':
 			config->startup_cmd = strdup(optarg);
 			break;
+		case 'D':
+			config->debug_damage_tracking = true;
+			break;
 		case 'h':
 		case '?':
 			usage(argv[0], c != 'h');

rootston/output.c

@@ -363,7 +363,7 @@ static void render_decorations(struct roots_view *view,
 		pixman_region32_rectangles(&damage, &nrects);
 	for (int i = 0; i < nrects; ++i) {
 		scissor_output(output, &rects[i]);
-		wlr_render_colored_quad(renderer, color, matrix);
+		wlr_render_quad_with_matrix(renderer, color, matrix);
 	}
 
 damage_finish:
@@ -486,6 +486,10 @@ static void render_output(struct roots_output *output) {
 		goto renderer_end;
 	}
 
+	if (server->config->debug_damage_tracking) {
+		wlr_renderer_clear(renderer, (float[]){1, 1, 0, 0});
+	}
+
 	int nrects;
 	pixman_box32_t *rects = pixman_region32_rectangles(&damage, &nrects);
 	for (int i = 0; i < nrects; ++i) {
@@ -667,7 +671,9 @@ static void damage_from_surface(struct wlr_surface *surface,
 	surface_intersect_output(surface, output->desktop->layout,
 		wlr_output, lx, ly, rotation, &box);
 
-	if (rotation == 0) {
+	int center_x = box.x + box.width/2;
+	int center_y = box.y + box.height/2;
+
 	pixman_region32_t damage;
 	pixman_region32_init(&damage);
 	pixman_region32_copy(&damage, &surface->current->surface_damage);
@@ -679,20 +685,9 @@ static void damage_from_surface(struct wlr_surface *surface,
 			ceil(wlr_output->scale) - surface->current->scale);
 	}
 	pixman_region32_translate(&damage, box.x, box.y);
+	wlr_region_rotated_bounds(&damage, &damage, rotation, center_x, center_y);
 	wlr_output_damage_add(output->damage, &damage);
 	pixman_region32_fini(&damage);
-	} else {
-		pixman_box32_t *extents =
-			pixman_region32_extents(&surface->current->surface_damage);
-		struct wlr_box damage_box = {
-			.x = box.x + extents->x1 * wlr_output->scale,
-			.y = box.y + extents->y1 * wlr_output->scale,
-			.width = (extents->x2 - extents->x1) * wlr_output->scale,
-			.height = (extents->y2 - extents->y1) * wlr_output->scale,
-		};
-		wlr_box_rotated_bounds(&damage_box, rotation, &damage_box);
-		wlr_output_damage_add_box(output->damage, &damage_box);
-	}
 }
 
 void output_damage_from_view(struct roots_output *output,

types/wlr_xdg_shell.c

@@ -194,7 +194,9 @@ static void xdg_surface_unmap(struct wlr_xdg_surface *surface) {
 	assert(surface->role != WLR_XDG_SURFACE_ROLE_NONE);
 
 	// TODO: probably need to ungrab before this event
+	if (surface->mapped) {
 		wlr_signal_emit_safe(&surface->events.unmap, surface);
+	}
 
 	if (surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL) {
 		wl_resource_set_user_data(surface->toplevel->resource, NULL);

types/wlr_xdg_shell_v6.c

@@ -194,7 +194,9 @@ static void xdg_surface_unmap(struct wlr_xdg_surface_v6 *surface) {
 	assert(surface->role != WLR_XDG_SURFACE_V6_ROLE_NONE);
 
 	// TODO: probably need to ungrab before this event
+	if (surface->mapped) {
 		wlr_signal_emit_safe(&surface->events.unmap, surface);
+	}
 
 	if (surface->role == WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL) {
 		wl_resource_set_user_data(surface->toplevel->resource, NULL);

util/region.c

@@ -128,3 +128,52 @@ void wlr_region_expand(pixman_region32_t *dst, pixman_region32_t *src,
 	pixman_region32_init_rects(dst, dst_rects, nrects);
 	free(dst_rects);
 }
+
+void wlr_region_rotated_bounds(pixman_region32_t *dst, pixman_region32_t *src,
+		float rotation, int ox, int oy) {
+	if (rotation == 0) {
+		pixman_region32_copy(dst, src);
+		return;
+	}
+
+	int nrects;
+	pixman_box32_t *src_rects = pixman_region32_rectangles(src, &nrects);
+
+	pixman_box32_t *dst_rects = malloc(nrects * sizeof(pixman_box32_t));
+	if (dst_rects == NULL) {
+		return;
+	}
+
+	for (int i = 0; i < nrects; ++i) {
+		double x1 = src_rects[i].x1 - ox;
+		double y1 = src_rects[i].y1 - oy;
+		double x2 = src_rects[i].x2 - ox;
+		double y2 = src_rects[i].y2 - oy;
+
+		double rx1 = x1 * cos(rotation) - y1 * sin(rotation);
+		double ry1 = x1 * sin(rotation) + y1 * cos(rotation);
+
+		double rx2 = x2 * cos(rotation) - y1 * sin(rotation);
+		double ry2 = x2 * sin(rotation) + y1 * cos(rotation);
+
+		double rx3 = x2 * cos(rotation) - y2 * sin(rotation);
+		double ry3 = x2 * sin(rotation) + y2 * cos(rotation);
+
+		double rx4 = x1 * cos(rotation) - y2 * sin(rotation);
+		double ry4 = x1 * sin(rotation) + y2 * cos(rotation);
+
+		x1 = fmin(fmin(rx1, rx2), fmin(rx3, rx4));
+		y1 = fmin(fmin(ry1, ry2), fmin(ry3, ry4));
+		x2 = fmax(fmax(rx1, rx2), fmax(rx3, rx4));
+		y2 = fmax(fmax(ry1, ry2), fmax(ry3, ry4));
+
+		dst_rects[i].x1 = floor(ox + x1);
+		dst_rects[i].x2 = ceil(ox + x2);
+		dst_rects[i].y1 = floor(oy + y1);
+		dst_rects[i].y2 = ceil(oy + y2);
+	}
+
+	pixman_region32_fini(dst);
+	pixman_region32_init_rects(dst, dst_rects, nrects);
+	free(dst_rects);
+}