render: introduce wlr_render_rect_pass

Split rectangle rendering out of wlr_render_pass and add a dedicated
wlr_render_rect_pass interface.

Remove the add_rect hook from wlr_render_pass_impl and implement
rectangle rendering separately in the pixman, GLES2 and Vulkan
renderers.

render/gles2/pass.c

@@ -287,7 +287,6 @@ static void render_pass_add_rect(struct wlr_render_pass *wlr_pass,
 static const struct wlr_render_pass_impl render_pass_impl = {
 	.submit = render_pass_submit,
 	.add_texture = render_pass_add_texture,
-	.add_rect = render_pass_add_rect,
 };
 
 static const char *reset_status_str(GLenum status) {
@@ -330,6 +329,7 @@ struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *b
 
 	wlr_render_pass_init(&pass->base, &render_pass_impl);
 	wlr_buffer_lock(wlr_buffer);
+	pass->base.renderer = &renderer->wlr_renderer;
 	pass->buffer = buffer;
 	pass->timer = timer;
 	pass->prev_ctx = *prev_ctx;
@@ -351,3 +351,43 @@ struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *b
 
 	return pass;
 }
+
+static void render_rect_pass_destroy(struct wlr_render_rect_pass *pass) {
+	struct wlr_gles2_render_rect_pass *gles2_pass =
+		wlr_gles2_render_rect_pass_from_pass(pass);
+	free(gles2_pass);
+}
+
+static const struct wlr_render_rect_pass_impl render_rect_pass_impl = {
+	.destroy = render_rect_pass_destroy,
+	.render = render_pass_add_rect,
+};
+
+struct wlr_render_rect_pass *wlr_gles2_render_rect_pass_create(void) {
+	struct wlr_gles2_render_rect_pass *pass = calloc(1, sizeof(*pass));
+	if (pass == NULL) {
+		wlr_log_errno(WLR_ERROR, "failed to allocate wlr_gles2_render_rect_pass");
+		return NULL;
+	}
+
+	wlr_render_rect_pass_init(&pass->base, &render_rect_pass_impl);
+
+	return &pass->base;
+}
+
+bool wlr_render_rect_pass_is_gles2(const struct wlr_render_rect_pass *rect_pass) {
+	return rect_pass != NULL && rect_pass->impl == &render_rect_pass_impl;
+}
+
+struct wlr_gles2_render_rect_pass *wlr_gles2_render_rect_pass_from_pass(
+		struct wlr_render_rect_pass *rect_pass) {
+	if (!wlr_render_rect_pass_is_gles2(rect_pass)) {
+		return NULL;
+	}
+
+	struct wlr_gles2_render_rect_pass *pass =
+		wl_container_of(rect_pass, pass, base);
+
+	return pass;
+}
+

render/pass.c

@@ -1,10 +1,23 @@
 #include <assert.h>
 #include <string.h>
+#include <stdlib.h>
 #include <wlr/render/interface.h>
+#include <wlr/util/log.h>
+#include <wlr/render/pixman.h>
+
+#include <wlr/config.h>
+
+#if WLR_HAS_GLES2_RENDERER
+#include <wlr/render/gles2.h>
+#endif
+
+#if WLR_HAS_VULKAN_RENDERER
+#include <wlr/render/vulkan.h>
+#endif
 
 void wlr_render_pass_init(struct wlr_render_pass *render_pass,
 		const struct wlr_render_pass_impl *impl) {
-	assert(impl->submit && impl->add_texture && impl->add_rect);
+	assert(impl->submit && impl->add_texture);
 	*render_pass = (struct wlr_render_pass){
 		.impl = impl,
 	};
@@ -31,7 +44,7 @@ void wlr_render_pass_add_texture(struct wlr_render_pass *render_pass,
 void wlr_render_pass_add_rect(struct wlr_render_pass *render_pass,
 		const struct wlr_render_rect_options *options) {
 	assert(options->box.width >= 0 && options->box.height >= 0);
-	render_pass->impl->add_rect(render_pass, options);
+	render_pass->renderer->rect_pass->impl->render(render_pass, options);
 }
 
 void wlr_render_texture_options_get_src_box(const struct wlr_render_texture_options *options,
@@ -74,3 +87,58 @@ void wlr_render_rect_options_get_box(const struct wlr_render_rect_options *optio
 
 	*box = options->box;
 }
+
+void wlr_render_rect_pass_init(struct wlr_render_rect_pass *render_pass,
+	const struct wlr_render_rect_pass_impl *impl) {
+	assert(impl->render);
+	*render_pass = (struct wlr_render_rect_pass){
+		.impl = impl,
+	};
+	wl_signal_init(&render_pass->events.destroy);
+}
+
+void wlr_render_rect_pass_destroy(struct wlr_render_rect_pass *render_pass) {
+	if (render_pass == NULL) {
+		return;
+	}
+
+	wl_signal_emit_mutable(&render_pass->events.destroy, NULL);
+	assert(wl_list_empty(&render_pass->events.destroy.listener_list));
+
+	if (render_pass->impl->destroy != NULL) {
+		render_pass->impl->destroy(render_pass);
+	} else {
+		free(render_pass);
+	}
+}
+
+struct wlr_render_rect_pass *get_or_create_render_rect_pass(
+		struct wlr_renderer *renderer) {
+	if (renderer == NULL) {
+		return NULL;
+	}
+
+	if (renderer->rect_pass == NULL) {
+		struct wlr_render_rect_pass *pass = NULL;
+		if (wlr_renderer_is_pixman(renderer)) {
+			pass = wlr_pixman_render_rect_pass_create();
+		}
+
+#if WLR_HAS_GLES2_RENDERER
+		else if (wlr_renderer_is_gles2(renderer)) {
+			pass = wlr_gles2_render_rect_pass_create();
+		}
+#endif
+
+#if WLR_HAS_VULKAN_RENDERER
+		else if (wlr_renderer_is_vk(renderer)) {
+			pass = wlr_vk_render_rect_pass_create();
+		}
+#endif
+
+		renderer->rect_pass = pass;
+		return pass;
+	} else {
+		return renderer->rect_pass;
+	}
+}

render/pixman/pass.c

@@ -1,5 +1,8 @@
 #include <assert.h>
 #include <stdlib.h>
+
+#include <wlr/util/log.h>
+
 #include "render/pixman.h"
 
 static const struct wlr_render_pass_impl render_pass_impl;
@@ -228,9 +231,47 @@ static void render_pass_add_rect(struct wlr_render_pass *wlr_pass,
 static const struct wlr_render_pass_impl render_pass_impl = {
 	.submit = render_pass_submit,
 	.add_texture = render_pass_add_texture,
-	.add_rect = render_pass_add_rect,
 };
 
+static void render_rect_pass_destroy(struct wlr_render_rect_pass *pass) {
+	struct wlr_pixman_render_rect_pass *pixman_pass =
+		wlr_pixman_render_rect_pass_from_pass(pass);
+	free(pixman_pass);
+}
+
+static const struct wlr_render_rect_pass_impl render_rect_pass_impl = {
+	.destroy = render_rect_pass_destroy,
+	.render = render_pass_add_rect,
+};
+
+struct wlr_render_rect_pass *wlr_pixman_render_rect_pass_create(void) {
+	struct wlr_pixman_render_rect_pass *pass = malloc(sizeof(*pass));
+	if (pass == NULL) {
+		wlr_log_errno(WLR_ERROR, "failed to allocate wlr_pixman_render_rect_pass");
+		return NULL;
+	}
+
+	wlr_render_rect_pass_init(&pass->base, &render_rect_pass_impl);
+
+	return &pass->base;
+}
+
+bool wlr_render_rect_pass_is_pixman(const struct wlr_render_rect_pass *rect_pass) {
+	return rect_pass->impl == &render_rect_pass_impl;
+}
+
+struct wlr_pixman_render_rect_pass *wlr_pixman_render_rect_pass_from_pass(
+		struct wlr_render_rect_pass *rect_pass) {
+	if (!wlr_render_rect_pass_is_pixman(rect_pass)) {
+		return NULL;
+	}
+
+	struct wlr_pixman_render_rect_pass *pass =
+		wl_container_of(rect_pass, pass, base);
+
+	return pass;
+}
+
 struct wlr_pixman_render_pass *begin_pixman_render_pass(
 		struct wlr_pixman_buffer *buffer) {
 	struct wlr_pixman_render_pass *pass = calloc(1, sizeof(*pass));
@@ -247,6 +288,7 @@ struct wlr_pixman_render_pass *begin_pixman_render_pass(
 	}
 
 	wlr_buffer_lock(buffer->buffer);
+	pass->base.renderer = &buffer->renderer->wlr_renderer;
 	pass->buffer = buffer;
 
 	return pass;

render/vulkan/pass.c

@@ -983,11 +983,9 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass,
 
 static const struct wlr_render_pass_impl render_pass_impl = {
 	.submit = render_pass_submit,
-	.add_rect = render_pass_add_rect,
 	.add_texture = render_pass_add_texture,
 };
 
-
 void vk_color_transform_destroy(struct wlr_addon *addon) {
 	struct wlr_vk_renderer *renderer = (struct wlr_vk_renderer *)addon->owner;
 	struct wlr_vk_color_transform *transform = wl_container_of(addon, transform, addon);
@@ -1289,6 +1287,7 @@ struct wlr_vk_render_pass *vulkan_begin_render_pass(struct wlr_vk_renderer *rend
 
 	wlr_render_pass_init(&pass->base, &render_pass_impl);
 	pass->renderer = renderer;
+	pass->base.renderer = &renderer->wlr_renderer;
 	pass->two_pass = using_two_pass_pathway;
 	if (options != NULL && options->color_transform != NULL) {
 		pass->color_transform = wlr_color_transform_ref(options->color_transform);
@@ -1355,3 +1354,42 @@ struct wlr_vk_render_pass *vulkan_begin_render_pass(struct wlr_vk_renderer *rend
 	pass->command_buffer = cb;
 	return pass;
 }
+
+static void render_rect_pass_destroy(struct wlr_render_rect_pass *pass) {
+	struct wlr_vk_render_rect_pass *vk_pass =
+		wlr_vk_render_rect_pass_from_pass(pass);
+	free(vk_pass);
+}
+
+static const struct wlr_render_rect_pass_impl render_rect_pass_impl = {
+	.destroy = render_rect_pass_destroy,
+	.render = render_pass_add_rect,
+};
+
+struct wlr_render_rect_pass *wlr_vk_render_rect_pass_create(void) {
+	struct wlr_vk_render_rect_pass *pass = calloc(1, sizeof(*pass));
+	if (pass == NULL) {
+		wlr_log_errno(WLR_ERROR, "failed to allocate wlr_vk_render_rect_pass");
+		return NULL;
+	}
+
+	wlr_render_rect_pass_init(&pass->base, &render_rect_pass_impl);
+
+	return &pass->base;
+}
+
+bool wlr_render_rect_pass_is_vk(const struct wlr_render_rect_pass *rect_pass) {
+	return rect_pass->impl == &render_rect_pass_impl;
+}
+
+struct wlr_vk_render_rect_pass *wlr_vk_render_rect_pass_from_pass(
+		struct wlr_render_rect_pass *rect_pass) {
+	if (!wlr_render_rect_pass_is_vk(rect_pass)) {
+		return NULL;
+	}
+
+	struct wlr_vk_render_rect_pass *pass =
+		wl_container_of(rect_pass, pass, base);
+
+	return pass;
+}

render/wlr_renderer.c

@@ -53,6 +53,7 @@ void wlr_renderer_destroy(struct wlr_renderer *r) {
 	assert(wl_list_empty(&r->events.destroy.listener_list));
 	assert(wl_list_empty(&r->events.lost.listener_list));
 
+	wlr_render_rect_pass_destroy(r->rect_pass);
 	if (r->impl && r->impl->destroy) {
 		r->impl->destroy(r);
 	} else {